Home | History | Annotate | Download | only in scriptc
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 // Don't edit this file!  It is auto-generated by frameworks/rs/api/generate.sh.
     18 
     19 /*
     20  * rs_matrix.rsh: Matrix Functions
     21  *
     22  * These functions let you manipulate square matrices of rank 2x2, 3x3, and 4x4.
     23  * They are particularly useful for graphical transformations and are compatible
     24  * with OpenGL.
     25  *
     26  * We use a zero-based index for rows and columns.  E.g. the last element of a
     27  * rs_matrix4x4 is found at (3, 3).
     28  *
     29  * RenderScript uses column-major matrices and column-based vectors.  Transforming
     30  * a vector is done by postmultiplying the vector, e.g. (matrix * vector),
     31  * as provided by rsMatrixMultiply().
     32  *
     33  * To create a transformation matrix that performs two transformations at once,
     34  * multiply the two source matrices, with the first transformation as the right
     35  * argument.  E.g. to create a transformation matrix that applies the
     36  * transformation s1 followed by s2, call rsMatrixLoadMultiply(&combined, &s2, &s1).
     37  * This derives from s2 * (s1 * v), which is (s2 * s1) * v.
     38  *
     39  * We have two style of functions to create transformation matrices:
     40  * rsMatrixLoadTransformation and rsMatrixTransformation.  The former
     41  * style simply stores the transformation matrix in the first argument.  The latter
     42  * modifies a pre-existing transformation matrix so that the new transformation
     43  * happens first.  E.g. if you call rsMatrixTranslate() on a matrix that already
     44  * does a scaling, the resulting matrix when applied to a vector will first do the
     45  * translation then the scaling.
     46  */
     47 
     48 #ifndef RENDERSCRIPT_RS_MATRIX_RSH
     49 #define RENDERSCRIPT_RS_MATRIX_RSH
     50 
     51 #include "rs_vector_math.rsh"
     52 
     53 /*
     54  * rsExtractFrustumPlanes: Compute frustum planes
     55  *
     56  * Computes 6 frustum planes from the view projection matrix
     57  *
     58  * Parameters:
     59  *   viewProj: Matrix to extract planes from.
     60  *   left: Left plane.
     61  *   right: Right plane.
     62  *   top: Top plane.
     63  *   bottom: Bottom plane.
     64  *   near: Near plane.
     65  *   far: Far plane.
     66  */
     67 #if !defined(RS_VERSION) || (RS_VERSION <= 23)
     68 static inline void __attribute__((overloadable))
     69     rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* right, float4* top,
     70                            float4* bottom, float4* near, float4* far) {
     71     // x y z w = a b c d in the plane equation
     72     left->x = viewProj->m[3] + viewProj->m[0];
     73     left->y = viewProj->m[7] + viewProj->m[4];
     74     left->z = viewProj->m[11] + viewProj->m[8];
     75     left->w = viewProj->m[15] + viewProj->m[12];
     76 
     77     right->x = viewProj->m[3] - viewProj->m[0];
     78     right->y = viewProj->m[7] - viewProj->m[4];
     79     right->z = viewProj->m[11] - viewProj->m[8];
     80     right->w = viewProj->m[15] - viewProj->m[12];
     81 
     82     top->x = viewProj->m[3] - viewProj->m[1];
     83     top->y = viewProj->m[7] - viewProj->m[5];
     84     top->z = viewProj->m[11] - viewProj->m[9];
     85     top->w = viewProj->m[15] - viewProj->m[13];
     86 
     87     bottom->x = viewProj->m[3] + viewProj->m[1];
     88     bottom->y = viewProj->m[7] + viewProj->m[5];
     89     bottom->z = viewProj->m[11] + viewProj->m[9];
     90     bottom->w = viewProj->m[15] + viewProj->m[13];
     91 
     92     near->x = viewProj->m[3] + viewProj->m[2];
     93     near->y = viewProj->m[7] + viewProj->m[6];
     94     near->z = viewProj->m[11] + viewProj->m[10];
     95     near->w = viewProj->m[15] + viewProj->m[14];
     96 
     97     far->x = viewProj->m[3] - viewProj->m[2];
     98     far->y = viewProj->m[7] - viewProj->m[6];
     99     far->z = viewProj->m[11] - viewProj->m[10];
    100     far->w = viewProj->m[15] - viewProj->m[14];
    101 
    102     float len = length(left->xyz);
    103     *left /= len;
    104     len = length(right->xyz);
    105     *right /= len;
    106     len = length(top->xyz);
    107     *top /= len;
    108     len = length(bottom->xyz);
    109     *bottom /= len;
    110     len = length(near->xyz);
    111     *near /= len;
    112     len = length(far->xyz);
    113     *far /= len;
    114 }
    115 #endif
    116 
    117 #if (defined(RS_VERSION) && (RS_VERSION >= 24))
    118 extern void __attribute__((overloadable))
    119     rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* righ, float4* top,
    120                            float4* bottom, float4* near, float4* far);
    121 #endif
    122 
    123 /*
    124  * rsIsSphereInFrustum: Checks if a sphere is within the frustum planes
    125  *
    126  * Returns true if the sphere is within the 6 frustum planes.
    127  *
    128  * Parameters:
    129  *   sphere: float4 representing the sphere.
    130  *   left: Left plane.
    131  *   right: Right plane.
    132  *   top: Top plane.
    133  *   bottom: Bottom plane.
    134  *   near: Near plane.
    135  *   far: Far plane.
    136  */
    137 #if !defined(RS_VERSION) || (RS_VERSION <= 23)
    138 static inline bool __attribute__((always_inline, overloadable))
    139     rsIsSphereInFrustum(float4* sphere, float4* left, float4* right, float4* top, float4* bottom,
    140                         float4* near, float4* far) {
    141     float distToCenter = dot(left->xyz, sphere->xyz) + left->w;
    142     if (distToCenter < -sphere->w) {
    143         return false;
    144     }
    145     distToCenter = dot(right->xyz, sphere->xyz) + right->w;
    146     if (distToCenter < -sphere->w) {
    147         return false;
    148     }
    149     distToCenter = dot(top->xyz, sphere->xyz) + top->w;
    150     if (distToCenter < -sphere->w) {
    151         return false;
    152     }
    153     distToCenter = dot(bottom->xyz, sphere->xyz) + bottom->w;
    154     if (distToCenter < -sphere->w) {
    155         return false;
    156     }
    157     distToCenter = dot(near->xyz, sphere->xyz) + near->w;
    158     if (distToCenter < -sphere->w) {
    159         return false;
    160     }
    161     distToCenter = dot(far->xyz, sphere->xyz) + far->w;
    162     if (distToCenter < -sphere->w) {
    163         return false;
    164     }
    165     return true;
    166 }
    167 #endif
    168 
    169 #if (defined(RS_VERSION) && (RS_VERSION >= 24))
    170 extern bool __attribute__((overloadable))
    171     rsIsSphereInFrustum(float4* sphere, float4* left, float4* right, float4* top, float4* bottom,
    172                         float4* near, float4* far);
    173 #endif
    174 
    175 /*
    176  * rsMatrixGet: Get one element
    177  *
    178  * Returns one element of a matrix.
    179  *
    180  * Warning: The order of the column and row parameters may be unexpected.
    181  *
    182  * Parameters:
    183  *   m: Matrix to extract the element from.
    184  *   col: Zero-based column of the element to be extracted.
    185  *   row: Zero-based row of the element to extracted.
    186  */
    187 extern float __attribute__((overloadable))
    188     rsMatrixGet(const rs_matrix4x4* m, uint32_t col, uint32_t row);
    189 
    190 extern float __attribute__((overloadable))
    191     rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t row);
    192 
    193 extern float __attribute__((overloadable))
    194     rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t row);
    195 
    196 /*
    197  * rsMatrixInverse: Inverts a matrix in place
    198  *
    199  * Returns true if the matrix was successfully inverted.
    200  *
    201  * Parameters:
    202  *   m: Matrix to invert.
    203  */
    204 extern bool __attribute__((overloadable))
    205     rsMatrixInverse(rs_matrix4x4* m);
    206 
    207 /*
    208  * rsMatrixInverseTranspose: Inverts and transpose a matrix in place
    209  *
    210  * The matrix is first inverted then transposed. Returns true if the matrix was
    211  * successfully inverted.
    212  *
    213  * Parameters:
    214  *   m: Matrix to modify.
    215  */
    216 extern bool __attribute__((overloadable))
    217     rsMatrixInverseTranspose(rs_matrix4x4* m);
    218 
    219 /*
    220  * rsMatrixLoad: Load or copy a matrix
    221  *
    222  * Set the elements of a matrix from an array of floats or from another matrix.
    223  *
    224  * If loading from an array, the floats should be in row-major order, i.e. the element a
    225  * row 0, column 0 should be first, followed by the element at
    226  * row 0, column 1, etc.
    227  *
    228  * If loading from a matrix and the source is smaller than the destination, the rest
    229  * of the destination is filled with elements of the identity matrix.  E.g.
    230  * loading a rs_matrix2x2 into a rs_matrix4x4 will give:
    231  *
    232  * m00 m01 0.0 0.0
    233  * m10 m11 0.0 0.0
    234  * 0.0 0.0 1.0 0.0
    235  * 0.0 0.0 0.0 1.0
    236  *
    237  *
    238  * Parameters:
    239  *   destination: Matrix to set.
    240  *   array: Array of values to set the matrix to. These arrays should be 4, 9, or 16 floats long, depending on the matrix size.
    241  *   source: Source matrix.
    242  */
    243 extern void __attribute__((overloadable))
    244     rsMatrixLoad(rs_matrix4x4* destination, const float* array);
    245 
    246 extern void __attribute__((overloadable))
    247     rsMatrixLoad(rs_matrix3x3* destination, const float* array);
    248 
    249 extern void __attribute__((overloadable))
    250     rsMatrixLoad(rs_matrix2x2* destination, const float* array);
    251 
    252 extern void __attribute__((overloadable))
    253     rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix4x4* source);
    254 
    255 extern void __attribute__((overloadable))
    256     rsMatrixLoad(rs_matrix3x3* destination, const rs_matrix3x3* source);
    257 
    258 extern void __attribute__((overloadable))
    259     rsMatrixLoad(rs_matrix2x2* destination, const rs_matrix2x2* source);
    260 
    261 extern void __attribute__((overloadable))
    262     rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix3x3* source);
    263 
    264 extern void __attribute__((overloadable))
    265     rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix2x2* source);
    266 
    267 /*
    268  * rsMatrixLoadFrustum: Load a frustum projection matrix
    269  *
    270  * Constructs a frustum projection matrix, transforming the box identified by
    271  * the six clipping planes left, right, bottom, top, near, far.
    272  *
    273  * To apply this projection to a vector, multiply the vector by the created
    274  * matrix using rsMatrixMultiply().
    275  *
    276  * Parameters:
    277  *   m: Matrix to set.
    278  */
    279 extern void __attribute__((overloadable))
    280     rsMatrixLoadFrustum(rs_matrix4x4* m, float left, float right, float bottom, float top,
    281                         float near, float far);
    282 
    283 /*
    284  * rsMatrixLoadIdentity: Load identity matrix
    285  *
    286  * Set the elements of a matrix to the identity matrix.
    287  *
    288  * Parameters:
    289  *   m: Matrix to set.
    290  */
    291 extern void __attribute__((overloadable))
    292     rsMatrixLoadIdentity(rs_matrix4x4* m);
    293 
    294 extern void __attribute__((overloadable))
    295     rsMatrixLoadIdentity(rs_matrix3x3* m);
    296 
    297 extern void __attribute__((overloadable))
    298     rsMatrixLoadIdentity(rs_matrix2x2* m);
    299 
    300 /*
    301  * rsMatrixLoadMultiply: Multiply two matrices
    302  *
    303  * Sets m to the matrix product of lhs * rhs.
    304  *
    305  * To combine two 4x4 transformaton matrices, multiply the second transformation matrix
    306  * by the first transformation matrix.  E.g. to create a transformation matrix that applies
    307  * the transformation s1 followed by s2, call rsMatrixLoadMultiply(&combined, &s2, &s1).
    308  *
    309  * Warning: Prior to version 21, storing the result back into right matrix is not supported and
    310  * will result in undefined behavior.  Use rsMatrixMulitply instead.   E.g. instead of doing
    311  * rsMatrixLoadMultiply (&m2r, &m2r, &m2l), use rsMatrixMultiply (&m2r, &m2l).
    312  * rsMatrixLoadMultiply (&m2l, &m2r, &m2l) works as expected.
    313  *
    314  * Parameters:
    315  *   m: Matrix to set.
    316  *   lhs: Left matrix of the product.
    317  *   rhs: Right matrix of the product.
    318  */
    319 extern void __attribute__((overloadable))
    320     rsMatrixLoadMultiply(rs_matrix4x4* m, const rs_matrix4x4* lhs, const rs_matrix4x4* rhs);
    321 
    322 extern void __attribute__((overloadable))
    323     rsMatrixLoadMultiply(rs_matrix3x3* m, const rs_matrix3x3* lhs, const rs_matrix3x3* rhs);
    324 
    325 extern void __attribute__((overloadable))
    326     rsMatrixLoadMultiply(rs_matrix2x2* m, const rs_matrix2x2* lhs, const rs_matrix2x2* rhs);
    327 
    328 /*
    329  * rsMatrixLoadOrtho: Load an orthographic projection matrix
    330  *
    331  * Constructs an orthographic projection matrix, transforming the box identified by the
    332  * six clipping planes left, right, bottom, top, near, far into a unit cube
    333  * with a corner at (-1, -1, -1) and the opposite at (1, 1, 1).
    334  *
    335  * To apply this projection to a vector, multiply the vector by the created matrix
    336  * using rsMatrixMultiply().
    337  *
    338  * See https://en.wikipedia.org/wiki/Orthographic_projection .
    339  *
    340  * Parameters:
    341  *   m: Matrix to set.
    342  */
    343 extern void __attribute__((overloadable))
    344     rsMatrixLoadOrtho(rs_matrix4x4* m, float left, float right, float bottom, float top, float near,
    345                       float far);
    346 
    347 /*
    348  * rsMatrixLoadPerspective: Load a perspective projection matrix
    349  *
    350  * Constructs a perspective projection matrix, assuming a symmetrical field of view.
    351  *
    352  * To apply this projection to a vector, multiply the vector by the created matrix
    353  * using rsMatrixMultiply().
    354  *
    355  * Parameters:
    356  *   m: Matrix to set.
    357  *   fovy: Field of view, in degrees along the Y axis.
    358  *   aspect: Ratio of x / y.
    359  *   near: Near clipping plane.
    360  *   far: Far clipping plane.
    361  */
    362 extern void __attribute__((overloadable))
    363     rsMatrixLoadPerspective(rs_matrix4x4* m, float fovy, float aspect, float near, float far);
    364 
    365 /*
    366  * rsMatrixLoadRotate: Load a rotation matrix
    367  *
    368  * This function creates a rotation matrix.  The axis of rotation is the (x, y, z) vector.
    369  *
    370  * To rotate a vector, multiply the vector by the created matrix using rsMatrixMultiply().
    371  *
    372  * See http://en.wikipedia.org/wiki/Rotation_matrix .
    373  *
    374  * Parameters:
    375  *   m: Matrix to set.
    376  *   rot: How much rotation to do, in degrees.
    377  *   x: X component of the vector that is the axis of rotation.
    378  *   y: Y component of the vector that is the axis of rotation.
    379  *   z: Z component of the vector that is the axis of rotation.
    380  */
    381 extern void __attribute__((overloadable))
    382     rsMatrixLoadRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
    383 
    384 /*
    385  * rsMatrixLoadScale: Load a scaling matrix
    386  *
    387  * This function creates a scaling matrix, where each component of a vector is multiplied
    388  * by a number.  This number can be negative.
    389  *
    390  * To scale a vector, multiply the vector by the created matrix using rsMatrixMultiply().
    391  *
    392  * Parameters:
    393  *   m: Matrix to set.
    394  *   x: Multiple to scale the x components by.
    395  *   y: Multiple to scale the y components by.
    396  *   z: Multiple to scale the z components by.
    397  */
    398 extern void __attribute__((overloadable))
    399     rsMatrixLoadScale(rs_matrix4x4* m, float x, float y, float z);
    400 
    401 /*
    402  * rsMatrixLoadTranslate: Load a translation matrix
    403  *
    404  * This function creates a translation matrix, where a number is added to each element of
    405  * a vector.
    406  *
    407  * To translate a vector, multiply the vector by the created matrix using
    408  * rsMatrixMultiply().
    409  *
    410  * Parameters:
    411  *   m: Matrix to set.
    412  *   x: Number to add to each x component.
    413  *   y: Number to add to each y component.
    414  *   z: Number to add to each z component.
    415  */
    416 extern void __attribute__((overloadable))
    417     rsMatrixLoadTranslate(rs_matrix4x4* m, float x, float y, float z);
    418 
    419 /*
    420  * rsMatrixMultiply: Multiply a matrix by a vector or another matrix
    421  *
    422  * For the matrix by matrix variant, sets m to the matrix product m * rhs.
    423  *
    424  * When combining two 4x4 transformation matrices using this function, the resulting
    425  * matrix will correspond to performing the rhs transformation first followed by
    426  * the original m transformation.
    427  *
    428  * For the matrix by vector variant, returns the post-multiplication of the vector
    429  * by the matrix, ie. m * in.
    430  *
    431  * When multiplying a float3 to a rs_matrix4x4, the vector is expanded with (1).
    432  *
    433  * When multiplying a float2 to a rs_matrix4x4, the vector is expanded with (0, 1).
    434  *
    435  * When multiplying a float2 to a rs_matrix3x3, the vector is expanded with (0).
    436  *
    437  * Starting with API 14, this function takes a const matrix as the first argument.
    438  *
    439  * Parameters:
    440  *   m: Left matrix of the product and the matrix to be set.
    441  *   rhs: Right matrix of the product.
    442  */
    443 extern void __attribute__((overloadable))
    444     rsMatrixMultiply(rs_matrix4x4* m, const rs_matrix4x4* rhs);
    445 
    446 extern void __attribute__((overloadable))
    447     rsMatrixMultiply(rs_matrix3x3* m, const rs_matrix3x3* rhs);
    448 
    449 extern void __attribute__((overloadable))
    450     rsMatrixMultiply(rs_matrix2x2* m, const rs_matrix2x2* rhs);
    451 
    452 #if !defined(RS_VERSION) || (RS_VERSION <= 13)
    453 extern float4 __attribute__((overloadable))
    454     rsMatrixMultiply(rs_matrix4x4* m, float4 in);
    455 #endif
    456 
    457 #if !defined(RS_VERSION) || (RS_VERSION <= 13)
    458 extern float4 __attribute__((overloadable))
    459     rsMatrixMultiply(rs_matrix4x4* m, float3 in);
    460 #endif
    461 
    462 #if !defined(RS_VERSION) || (RS_VERSION <= 13)
    463 extern float4 __attribute__((overloadable))
    464     rsMatrixMultiply(rs_matrix4x4* m, float2 in);
    465 #endif
    466 
    467 #if !defined(RS_VERSION) || (RS_VERSION <= 13)
    468 extern float3 __attribute__((overloadable))
    469     rsMatrixMultiply(rs_matrix3x3* m, float3 in);
    470 #endif
    471 
    472 #if !defined(RS_VERSION) || (RS_VERSION <= 13)
    473 extern float3 __attribute__((overloadable))
    474     rsMatrixMultiply(rs_matrix3x3* m, float2 in);
    475 #endif
    476 
    477 #if !defined(RS_VERSION) || (RS_VERSION <= 13)
    478 extern float2 __attribute__((overloadable))
    479     rsMatrixMultiply(rs_matrix2x2* m, float2 in);
    480 #endif
    481 
    482 #if (defined(RS_VERSION) && (RS_VERSION >= 14))
    483 extern float4 __attribute__((overloadable))
    484     rsMatrixMultiply(const rs_matrix4x4* m, float4 in);
    485 #endif
    486 
    487 #if (defined(RS_VERSION) && (RS_VERSION >= 14))
    488 extern float4 __attribute__((overloadable))
    489     rsMatrixMultiply(const rs_matrix4x4* m, float3 in);
    490 #endif
    491 
    492 #if (defined(RS_VERSION) && (RS_VERSION >= 14))
    493 extern float4 __attribute__((overloadable))
    494     rsMatrixMultiply(const rs_matrix4x4* m, float2 in);
    495 #endif
    496 
    497 #if (defined(RS_VERSION) && (RS_VERSION >= 14))
    498 extern float3 __attribute__((overloadable))
    499     rsMatrixMultiply(const rs_matrix3x3* m, float3 in);
    500 #endif
    501 
    502 #if (defined(RS_VERSION) && (RS_VERSION >= 14))
    503 extern float3 __attribute__((overloadable))
    504     rsMatrixMultiply(const rs_matrix3x3* m, float2 in);
    505 #endif
    506 
    507 #if (defined(RS_VERSION) && (RS_VERSION >= 14))
    508 extern float2 __attribute__((overloadable))
    509     rsMatrixMultiply(const rs_matrix2x2* m, float2 in);
    510 #endif
    511 
    512 /*
    513  * rsMatrixRotate: Apply a rotation to a transformation matrix
    514  *
    515  * Multiply the matrix m with a rotation matrix.
    516  *
    517  * This function modifies a transformation matrix to first do a rotation.  The axis of
    518  * rotation is the (x, y, z) vector.
    519  *
    520  * To apply this combined transformation to a vector, multiply the vector by the created
    521  * matrix using rsMatrixMultiply().
    522  *
    523  * Parameters:
    524  *   m: Matrix to modify.
    525  *   rot: How much rotation to do, in degrees.
    526  *   x: X component of the vector that is the axis of rotation.
    527  *   y: Y component of the vector that is the axis of rotation.
    528  *   z: Z component of the vector that is the axis of rotation.
    529  */
    530 extern void __attribute__((overloadable))
    531     rsMatrixRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
    532 
    533 /*
    534  * rsMatrixScale: Apply a scaling to a transformation matrix
    535  *
    536  * Multiply the matrix m with a scaling matrix.
    537  *
    538  * This function modifies a transformation matrix to first do a scaling.   When scaling,
    539  * each component of a vector is multiplied by a number.  This number can be negative.
    540  *
    541  * To apply this combined transformation to a vector, multiply the vector by the created
    542  * matrix using rsMatrixMultiply().
    543  *
    544  * Parameters:
    545  *   m: Matrix to modify.
    546  *   x: Multiple to scale the x components by.
    547  *   y: Multiple to scale the y components by.
    548  *   z: Multiple to scale the z components by.
    549  */
    550 extern void __attribute__((overloadable))
    551     rsMatrixScale(rs_matrix4x4* m, float x, float y, float z);
    552 
    553 /*
    554  * rsMatrixSet: Set one element
    555  *
    556  * Set an element of a matrix.
    557  *
    558  * Warning: The order of the column and row parameters may be unexpected.
    559  *
    560  * Parameters:
    561  *   m: Matrix that will be modified.
    562  *   col: Zero-based column of the element to be set.
    563  *   row: Zero-based row of the element to be set.
    564  *   v: Value to set.
    565  */
    566 extern void __attribute__((overloadable))
    567     rsMatrixSet(rs_matrix4x4* m, uint32_t col, uint32_t row, float v);
    568 
    569 extern void __attribute__((overloadable))
    570     rsMatrixSet(rs_matrix3x3* m, uint32_t col, uint32_t row, float v);
    571 
    572 extern void __attribute__((overloadable))
    573     rsMatrixSet(rs_matrix2x2* m, uint32_t col, uint32_t row, float v);
    574 
    575 /*
    576  * rsMatrixTranslate: Apply a translation to a transformation matrix
    577  *
    578  * Multiply the matrix m with a translation matrix.
    579  *
    580  * This function modifies a transformation matrix to first do a translation.  When
    581  * translating, a number is added to each component of a vector.
    582  *
    583  * To apply this combined transformation to a vector, multiply the vector by the
    584  * created matrix using rsMatrixMultiply().
    585  *
    586  * Parameters:
    587  *   m: Matrix to modify.
    588  *   x: Number to add to each x component.
    589  *   y: Number to add to each y component.
    590  *   z: Number to add to each z component.
    591  */
    592 extern void __attribute__((overloadable))
    593     rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z);
    594 
    595 /*
    596  * rsMatrixTranspose: Transpose a matrix place
    597  *
    598  * Transpose the matrix m in place.
    599  *
    600  * Parameters:
    601  *   m: Matrix to transpose.
    602  */
    603 extern void __attribute__((overloadable))
    604     rsMatrixTranspose(rs_matrix4x4* m);
    605 
    606 extern void __attribute__((overloadable))
    607     rsMatrixTranspose(rs_matrix3x3* m);
    608 
    609 extern void __attribute__((overloadable))
    610     rsMatrixTranspose(rs_matrix2x2* m);
    611 
    612 #endif // RENDERSCRIPT_RS_MATRIX_RSH
    613