blob: aafc864da68ac575d66afc0336fc32b4521f7fd3 [file] [log] [blame]
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Don't edit this file! It is auto-generated by frameworks/rs/api/generate.sh.
/*
* rs_matrix.rsh: Matrix Functions
*
* These functions let you manipulate square matrices of rank 2x2, 3x3, and 4x4.
* They are particularly useful for graphical transformations and are compatible
* with OpenGL.
*
* We use a zero-based index for rows and columns. E.g. the last element of a
* rs_matrix4x4 is found at (3, 3).
*
* RenderScript uses column-major matrices and column-based vectors. Transforming
* a vector is done by postmultiplying the vector, e.g. (matrix * vector),
* as provided by rsMatrixMultiply().
*
* To create a transformation matrix that performs two transformations at once,
* multiply the two source matrices, with the first transformation as the right
* argument. E.g. to create a transformation matrix that applies the
* transformation s1 followed by s2, call rsMatrixLoadMultiply(&combined, &s2, &s1).
* This derives from s2 * (s1 * v), which is (s2 * s1) * v.
*
* We have two style of functions to create transformation matrices:
* rsMatrixLoadTransformation and rsMatrixTransformation. The former
* style simply stores the transformation matrix in the first argument. The latter
* modifies a pre-existing transformation matrix so that the new transformation
* happens first. E.g. if you call rsMatrixTranslate() on a matrix that already
* does a scaling, the resulting matrix when applied to a vector will first do the
* translation then the scaling.
*/
#ifndef RENDERSCRIPT_RS_MATRIX_RSH
#define RENDERSCRIPT_RS_MATRIX_RSH
#include "rs_vector_math.rsh"
/*
* rsExtractFrustumPlanes: Compute frustum planes
*
* Computes 6 frustum planes from the view projection matrix
*
* Parameters:
* viewProj: Matrix to extract planes from.
* left: Left plane.
* right: Right plane.
* top: Top plane.
* bottom: Bottom plane.
* near: Near plane.
* far: Far plane.
*/
static inline void __attribute__((always_inline, overloadable))
rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* right, float4* top,
float4* bottom, float4* near, float4* far) {
// x y z w = a b c d in the plane equation
left->x = viewProj->m[3] + viewProj->m[0];
left->y = viewProj->m[7] + viewProj->m[4];
left->z = viewProj->m[11] + viewProj->m[8];
left->w = viewProj->m[15] + viewProj->m[12];
right->x = viewProj->m[3] - viewProj->m[0];
right->y = viewProj->m[7] - viewProj->m[4];
right->z = viewProj->m[11] - viewProj->m[8];
right->w = viewProj->m[15] - viewProj->m[12];
top->x = viewProj->m[3] - viewProj->m[1];
top->y = viewProj->m[7] - viewProj->m[5];
top->z = viewProj->m[11] - viewProj->m[9];
top->w = viewProj->m[15] - viewProj->m[13];
bottom->x = viewProj->m[3] + viewProj->m[1];
bottom->y = viewProj->m[7] + viewProj->m[5];
bottom->z = viewProj->m[11] + viewProj->m[9];
bottom->w = viewProj->m[15] + viewProj->m[13];
near->x = viewProj->m[3] + viewProj->m[2];
near->y = viewProj->m[7] + viewProj->m[6];
near->z = viewProj->m[11] + viewProj->m[10];
near->w = viewProj->m[15] + viewProj->m[14];
far->x = viewProj->m[3] - viewProj->m[2];
far->y = viewProj->m[7] - viewProj->m[6];
far->z = viewProj->m[11] - viewProj->m[10];
far->w = viewProj->m[15] - viewProj->m[14];
float len = length(left->xyz);
*left /= len;
len = length(right->xyz);
*right /= len;
len = length(top->xyz);
*top /= len;
len = length(bottom->xyz);
*bottom /= len;
len = length(near->xyz);
*near /= len;
len = length(far->xyz);
*far /= len;
}
/*
* rsIsSphereInFrustum: Checks if a sphere is within the frustum planes
*
* Returns true if the sphere is within the 6 frustum planes.
*
* Parameters:
* sphere: float4 representing the sphere.
* left: Left plane.
* right: Right plane.
* top: Top plane.
* bottom: Bottom plane.
* near: Near plane.
* far: Far plane.
*/
static inline bool __attribute__((always_inline, overloadable))
rsIsSphereInFrustum(float4* sphere, float4* left, float4* right, float4* top, float4* bottom,
float4* near, float4* far) {
float distToCenter = dot(left->xyz, sphere->xyz) + left->w;
if (distToCenter < -sphere->w) {
return false;
}
distToCenter = dot(right->xyz, sphere->xyz) + right->w;
if (distToCenter < -sphere->w) {
return false;
}
distToCenter = dot(top->xyz, sphere->xyz) + top->w;
if (distToCenter < -sphere->w) {
return false;
}
distToCenter = dot(bottom->xyz, sphere->xyz) + bottom->w;
if (distToCenter < -sphere->w) {
return false;
}
distToCenter = dot(near->xyz, sphere->xyz) + near->w;
if (distToCenter < -sphere->w) {
return false;
}
distToCenter = dot(far->xyz, sphere->xyz) + far->w;
if (distToCenter < -sphere->w) {
return false;
}
return true;
}
/*
* rsMatrixGet: Get one element
*
* Returns one element of a matrix.
*
* Warning: The order of the column and row parameters may be unexpected.
*
* Parameters:
* m: Matrix to extract the element from.
* col: Zero-based column of the element to be extracted.
* row: Zero-based row of the element to extracted.
*/
extern float __attribute__((overloadable))
rsMatrixGet(const rs_matrix4x4* m, uint32_t col, uint32_t row);
extern float __attribute__((overloadable))
rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t row);
extern float __attribute__((overloadable))
rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t row);
/*
* rsMatrixInverse: Inverts a matrix in place
*
* Returns true if the matrix was successfully inverted.
*
* Parameters:
* m: Matrix to invert.
*/
extern bool __attribute__((overloadable))
rsMatrixInverse(rs_matrix4x4* m);
/*
* rsMatrixInverseTranspose: Inverts and transpose a matrix in place
*
* The matrix is first inverted then transposed. Returns true if the matrix was
* successfully inverted.
*
* Parameters:
* m: Matrix to modify.
*/
extern bool __attribute__((overloadable))
rsMatrixInverseTranspose(rs_matrix4x4* m);
/*
* rsMatrixLoad: Load or copy a matrix
*
* Set the elements of a matrix from an array of floats or from another matrix.
*
* If loading from an array, the floats should be in row-major order, i.e. the element a
* row 0, column 0 should be first, followed by the element at
* row 0, column 1, etc.
*
* If loading from a matrix and the source is smaller than the destination, the rest
* of the destination is filled with elements of the identity matrix. E.g.
* loading a rs_matrix2x2 into a rs_matrix4x4 will give:
*
* m00 m01 0.0 0.0
* m10 m11 0.0 0.0
* 0.0 0.0 1.0 0.0
* 0.0 0.0 0.0 1.0
*
*
* Parameters:
* destination: Matrix to set.
* array: Array of values to set the matrix to. These arrays should be 4, 9, or 16 floats long, depending on the matrix size.
* source: Source matrix.
*/
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix4x4* destination, const float* array);
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix3x3* destination, const float* array);
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix2x2* destination, const float* array);
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix4x4* source);
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix3x3* destination, const rs_matrix3x3* source);
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix2x2* destination, const rs_matrix2x2* source);
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix3x3* source);
extern void __attribute__((overloadable))
rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix2x2* source);
/*
* rsMatrixLoadFrustum: Load a frustum projection matrix
*
* Constructs a frustum projection matrix, transforming the box identified by
* the six clipping planes left, right, bottom, top, near, far.
*
* To apply this projection to a vector, multiply the vector by the created
* matrix using rsMatrixMultiply().
*
* Parameters:
* m: Matrix to set.
*/
extern void __attribute__((overloadable))
rsMatrixLoadFrustum(rs_matrix4x4* m, float left, float right, float bottom, float top,
float near, float far);
/*
* rsMatrixLoadIdentity: Load identity matrix
*
* Set the elements of a matrix to the identity matrix.
*
* Parameters:
* m: Matrix to set.
*/
extern void __attribute__((overloadable))
rsMatrixLoadIdentity(rs_matrix4x4* m);
extern void __attribute__((overloadable))
rsMatrixLoadIdentity(rs_matrix3x3* m);
extern void __attribute__((overloadable))
rsMatrixLoadIdentity(rs_matrix2x2* m);
/*
* rsMatrixLoadMultiply: Multiply two matrices
*
* Sets m to the matrix product of lhs * rhs.
*
* To combine two 4x4 transformaton matrices, multiply the second transformation matrix
* by the first transformation matrix. E.g. to create a transformation matrix that applies
* the transformation s1 followed by s2, call rsMatrixLoadMultiply(&combined, &s2, &s1).
*
* Warning: Prior to version 21, storing the result back into right matrix is not supported and
* will result in undefined behavior. Use rsMatrixMulitply instead. E.g. instead of doing
* rsMatrixLoadMultiply (&m2r, &m2r, &m2l), use rsMatrixMultiply (&m2r, &m2l).
* rsMatrixLoadMultiply (&m2l, &m2r, &m2l) works as expected.
*
* Parameters:
* m: Matrix to set.
* lhs: Left matrix of the product.
* rhs: Right matrix of the product.
*/
extern void __attribute__((overloadable))
rsMatrixLoadMultiply(rs_matrix4x4* m, const rs_matrix4x4* lhs, const rs_matrix4x4* rhs);
extern void __attribute__((overloadable))
rsMatrixLoadMultiply(rs_matrix3x3* m, const rs_matrix3x3* lhs, const rs_matrix3x3* rhs);
extern void __attribute__((overloadable))
rsMatrixLoadMultiply(rs_matrix2x2* m, const rs_matrix2x2* lhs, const rs_matrix2x2* rhs);
/*
* rsMatrixLoadOrtho: Load an orthographic projection matrix
*
* Constructs an orthographic projection matrix, transforming the box identified by the
* six clipping planes left, right, bottom, top, near, far into a unit cube
* with a corner at (-1, -1, -1) and the opposite at (1, 1, 1).
*
* To apply this projection to a vector, multiply the vector by the created matrix
* using rsMatrixMultiply().
*
* See https://en.wikipedia.org/wiki/Orthographic_projection .
*
* Parameters:
* m: Matrix to set.
*/
extern void __attribute__((overloadable))
rsMatrixLoadOrtho(rs_matrix4x4* m, float left, float right, float bottom, float top, float near,
float far);
/*
* rsMatrixLoadPerspective: Load a perspective projection matrix
*
* Constructs a perspective projection matrix, assuming a symmetrical field of view.
*
* To apply this projection to a vector, multiply the vector by the created matrix
* using rsMatrixMultiply().
*
* Parameters:
* m: Matrix to set.
* fovy: Field of view, in degrees along the Y axis.
* aspect: Ratio of x / y.
* near: Near clipping plane.
* far: Far clipping plane.
*/
extern void __attribute__((overloadable))
rsMatrixLoadPerspective(rs_matrix4x4* m, float fovy, float aspect, float near, float far);
/*
* rsMatrixLoadRotate: Load a rotation matrix
*
* This function creates a rotation matrix. The axis of rotation is the (x, y, z) vector.
*
* To rotate a vector, multiply the vector by the created matrix using rsMatrixMultiply().
*
* See http://en.wikipedia.org/wiki/Rotation_matrix .
*
* Parameters:
* m: Matrix to set.
* rot: How much rotation to do, in degrees.
* x: X component of the vector that is the axis of rotation.
* y: Y component of the vector that is the axis of rotation.
* z: Z component of the vector that is the axis of rotation.
*/
extern void __attribute__((overloadable))
rsMatrixLoadRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
/*
* rsMatrixLoadScale: Load a scaling matrix
*
* This function creates a scaling matrix, where each component of a vector is multiplied
* by a number. This number can be negative.
*
* To scale a vector, multiply the vector by the created matrix using rsMatrixMultiply().
*
* Parameters:
* m: Matrix to set.
* x: Multiple to scale the x components by.
* y: Multiple to scale the y components by.
* z: Multiple to scale the z components by.
*/
extern void __attribute__((overloadable))
rsMatrixLoadScale(rs_matrix4x4* m, float x, float y, float z);
/*
* rsMatrixLoadTranslate: Load a translation matrix
*
* This function creates a translation matrix, where a number is added to each element of
* a vector.
*
* To translate a vector, multiply the vector by the created matrix using
* rsMatrixMultiply().
*
* Parameters:
* m: Matrix to set.
* x: Number to add to each x component.
* y: Number to add to each y component.
* z: Number to add to each z component.
*/
extern void __attribute__((overloadable))
rsMatrixLoadTranslate(rs_matrix4x4* m, float x, float y, float z);
/*
* rsMatrixMultiply: Multiply a matrix by a vector or another matrix
*
* For the matrix by matrix variant, sets m to the matrix product m * rhs.
*
* When combining two 4x4 transformation matrices using this function, the resulting
* matrix will correspond to performing the rhs transformation first followed by
* the original m transformation.
*
* For the matrix by vector variant, returns the post-multiplication of the vector
* by the matrix, ie. m * in.
*
* When multiplying a float3 to a rs_matrix4x4, the vector is expanded with (1).
*
* When multiplying a float2 to a rs_matrix4x4, the vector is expanded with (0, 1).
*
* When multiplying a float2 to a rs_matrix3x3, the vector is expanded with (0).
*
* Starting with API 14, this function takes a const matrix as the first argument.
*
* Parameters:
* m: Left matrix of the product and the matrix to be set.
* rhs: Right matrix of the product.
*/
extern void __attribute__((overloadable))
rsMatrixMultiply(rs_matrix4x4* m, const rs_matrix4x4* rhs);
extern void __attribute__((overloadable))
rsMatrixMultiply(rs_matrix3x3* m, const rs_matrix3x3* rhs);
extern void __attribute__((overloadable))
rsMatrixMultiply(rs_matrix2x2* m, const rs_matrix2x2* rhs);
#if !defined(RS_VERSION) || (RS_VERSION <= 13)
extern float4 __attribute__((overloadable))
rsMatrixMultiply(rs_matrix4x4* m, float4 in);
#endif
#if !defined(RS_VERSION) || (RS_VERSION <= 13)
extern float4 __attribute__((overloadable))
rsMatrixMultiply(rs_matrix4x4* m, float3 in);
#endif
#if !defined(RS_VERSION) || (RS_VERSION <= 13)
extern float4 __attribute__((overloadable))
rsMatrixMultiply(rs_matrix4x4* m, float2 in);
#endif
#if !defined(RS_VERSION) || (RS_VERSION <= 13)
extern float3 __attribute__((overloadable))
rsMatrixMultiply(rs_matrix3x3* m, float3 in);
#endif
#if !defined(RS_VERSION) || (RS_VERSION <= 13)
extern float3 __attribute__((overloadable))
rsMatrixMultiply(rs_matrix3x3* m, float2 in);
#endif
#if !defined(RS_VERSION) || (RS_VERSION <= 13)
extern float2 __attribute__((overloadable))
rsMatrixMultiply(rs_matrix2x2* m, float2 in);
#endif
#if (defined(RS_VERSION) && (RS_VERSION >= 14))
extern float4 __attribute__((overloadable))
rsMatrixMultiply(const rs_matrix4x4* m, float4 in);
#endif
#if (defined(RS_VERSION) && (RS_VERSION >= 14))
extern float4 __attribute__((overloadable))
rsMatrixMultiply(const rs_matrix4x4* m, float3 in);
#endif
#if (defined(RS_VERSION) && (RS_VERSION >= 14))
extern float4 __attribute__((overloadable))
rsMatrixMultiply(const rs_matrix4x4* m, float2 in);
#endif
#if (defined(RS_VERSION) && (RS_VERSION >= 14))
extern float3 __attribute__((overloadable))
rsMatrixMultiply(const rs_matrix3x3* m, float3 in);
#endif
#if (defined(RS_VERSION) && (RS_VERSION >= 14))
extern float3 __attribute__((overloadable))
rsMatrixMultiply(const rs_matrix3x3* m, float2 in);
#endif
#if (defined(RS_VERSION) && (RS_VERSION >= 14))
extern float2 __attribute__((overloadable))
rsMatrixMultiply(const rs_matrix2x2* m, float2 in);
#endif
/*
* rsMatrixRotate: Apply a rotation to a transformation matrix
*
* Multiply the matrix m with a rotation matrix.
*
* This function modifies a transformation matrix to first do a rotation. The axis of
* rotation is the (x, y, z) vector.
*
* To apply this combined transformation to a vector, multiply the vector by the created
* matrix using rsMatrixMultiply().
*
* Parameters:
* m: Matrix to modify.
* rot: How much rotation to do, in degrees.
* x: X component of the vector that is the axis of rotation.
* y: Y component of the vector that is the axis of rotation.
* z: Z component of the vector that is the axis of rotation.
*/
extern void __attribute__((overloadable))
rsMatrixRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
/*
* rsMatrixScale: Apply a scaling to a transformation matrix
*
* Multiply the matrix m with a scaling matrix.
*
* This function modifies a transformation matrix to first do a scaling. When scaling,
* each component of a vector is multiplied by a number. This number can be negative.
*
* To apply this combined transformation to a vector, multiply the vector by the created
* matrix using rsMatrixMultiply().
*
* Parameters:
* m: Matrix to modify.
* x: Multiple to scale the x components by.
* y: Multiple to scale the y components by.
* z: Multiple to scale the z components by.
*/
extern void __attribute__((overloadable))
rsMatrixScale(rs_matrix4x4* m, float x, float y, float z);
/*
* rsMatrixSet: Set one element
*
* Set an element of a matrix.
*
* Warning: The order of the column and row parameters may be unexpected.
*
* Parameters:
* m: Matrix that will be modified.
* col: Zero-based column of the element to be set.
* row: Zero-based row of the element to be set.
* v: Value to set.
*/
extern void __attribute__((overloadable))
rsMatrixSet(rs_matrix4x4* m, uint32_t col, uint32_t row, float v);
extern void __attribute__((overloadable))
rsMatrixSet(rs_matrix3x3* m, uint32_t col, uint32_t row, float v);
extern void __attribute__((overloadable))
rsMatrixSet(rs_matrix2x2* m, uint32_t col, uint32_t row, float v);
/*
* rsMatrixTranslate: Apply a translation to a transformation matrix
*
* Multiply the matrix m with a translation matrix.
*
* This function modifies a transformation matrix to first do a translation. When
* translating, a number is added to each component of a vector.
*
* To apply this combined transformation to a vector, multiply the vector by the
* created matrix using rsMatrixMultiply().
*
* Parameters:
* m: Matrix to modify.
* x: Number to add to each x component.
* y: Number to add to each y component.
* z: Number to add to each z component.
*/
extern void __attribute__((overloadable))
rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z);
/*
* rsMatrixTranspose: Transpose a matrix place
*
* Transpose the matrix m in place.
*
* Parameters:
* m: Matrix to transpose.
*/
extern void __attribute__((overloadable))
rsMatrixTranspose(rs_matrix4x4* m);
extern void __attribute__((overloadable))
rsMatrixTranspose(rs_matrix3x3* m);
extern void __attribute__((overloadable))
rsMatrixTranspose(rs_matrix2x2* m);
#endif // RENDERSCRIPT_RS_MATRIX_RSH