You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
964 lines
32 KiB
964 lines
32 KiB
/**
|
|
Copyright 2013 BlackBerry Inc.
|
|
Copyright (c) 2014-2016 Chukong Technologies Inc.
|
|
Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
|
|
|
|
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.
|
|
|
|
Original file from GamePlay3D: http://gameplay3d.org
|
|
|
|
This file was modified to fit the cocos2d-x project
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "base/Macros.h"
|
|
|
|
#include "math/Vec3.h"
|
|
#include "math/Vec4.h"
|
|
|
|
#undef __SSE__
|
|
#ifdef __SSE__
|
|
#include <xmmintrin.h>
|
|
#endif
|
|
|
|
/**
|
|
* @addtogroup base
|
|
* @{
|
|
*/
|
|
|
|
NS_CC_MATH_BEGIN
|
|
|
|
//class Plane;
|
|
|
|
/**
|
|
* Defines a 4 x 4 floating point matrix representing a 3D transformation.
|
|
*
|
|
* Vectors are treated as columns, resulting in a matrix that is represented as follows,
|
|
* where x, y and z are the translation components of the matrix:
|
|
*
|
|
* 1 0 0 x
|
|
* 0 1 0 y
|
|
* 0 0 1 z
|
|
* 0 0 0 1
|
|
*
|
|
* This matrix class is directly compatible with OpenGL since its elements are
|
|
* laid out in memory exactly as they are expected by OpenGL.
|
|
* The matrix uses column-major format such that array indices increase down column first.
|
|
* Since matrix multiplication is not commutative, multiplication must be done in the
|
|
* correct order when combining transformations. Suppose we have a translation
|
|
* matrix T and a rotation matrix R. To first rotate an object around the origin
|
|
* and then translate it, you would multiply the two matrices as TR.
|
|
*
|
|
* Likewise, to first translate the object and then rotate it, you would do RT.
|
|
* So generally, matrices must be multiplied in the reverse order in which you
|
|
* want the transformations to take place (this also applies to
|
|
* the scale, rotate, and translate methods below; these methods are convenience
|
|
* methods for post-multiplying by a matrix representing a scale, rotation, or translation).
|
|
*
|
|
* In the case of repeated local transformations (i.e. rotate around the Z-axis by 0.76 radians,
|
|
* then translate by 2.1 along the X-axis, then ...), it is better to use the Transform class
|
|
* (which is optimized for that kind of usage).
|
|
*
|
|
* @see Transform
|
|
*/
|
|
class CC_DLL Mat4 {
|
|
public:
|
|
// //temp add conversion
|
|
// operator kmMat4() const
|
|
// {
|
|
// kmMat4 result;
|
|
// kmMat4Fill(&result, m);
|
|
// return result;
|
|
// }
|
|
|
|
// Mat4(const kmMat4& mat)
|
|
// {
|
|
// set(mat.mat);
|
|
// }
|
|
/**
|
|
* Stores the columns of this 4x4 matrix.
|
|
* matrix layout
|
|
* |m[0] m[4] m[8] m[12]|
|
|
* |m[1] m[5] m[9] m[13]|
|
|
* |m[2] m[6] m[10] m[14]|
|
|
* |m[3] m[7] m[11] m[15]|
|
|
*/
|
|
#ifdef __SSE__
|
|
union {
|
|
__m128 col[4];
|
|
float m[16];
|
|
};
|
|
#else
|
|
float m[16];
|
|
#endif
|
|
|
|
/**
|
|
* Default constructor.
|
|
* Constructs a matrix initialized to the identity matrix:
|
|
*
|
|
* 1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
*/
|
|
Mat4();
|
|
|
|
/**
|
|
* Constructs a matrix initialized to the specified value.
|
|
*
|
|
* @param m00 Component in column 0, row 0 position (index 0)
|
|
* @param m01 Component in column 0, row 1 position (index 1)
|
|
* @param m02 Component in column 0, row 2 position (index 2)
|
|
* @param m03 Component in column 0, row 3 position (index 3)
|
|
* @param m10 Component in column 1, row 0 position (index 4)
|
|
* @param m11 Component in column 1, row 1 position (index 5)
|
|
* @param m12 Component in column 1, row 2 position (index 6)
|
|
* @param m13 Component in column 1, row 3 position (index 7)
|
|
* @param m20 Component in column 2, row 0 position (index 8)
|
|
* @param m21 Component in column 2, row 1 position (index 9)
|
|
* @param m22 Component in column 2, row 2 position (index 10)
|
|
* @param m23 Component in column 2, row 3 position (index 11)
|
|
* @param m30 Component in column 3, row 0 position (index 12)
|
|
* @param m31 Component in column 3, row 1 position (index 13)
|
|
* @param m32 Component in column 3, row 2 position (index 14)
|
|
* @param m33 Component in column 3, row 3 position (index 15)
|
|
*/
|
|
Mat4(float m00, float m01, float m02, float m03,
|
|
float m10, float m11, float m12, float m13,
|
|
float m20, float m21, float m22, float m23,
|
|
float m30, float m31, float m32, float m33);
|
|
|
|
/**
|
|
* Creates a matrix initialized to the specified column-major array.
|
|
*
|
|
* The passed-in array is in column-major order, so the memory layout of the array is as follows:
|
|
*
|
|
* 0 4 8 12
|
|
* 1 5 9 13
|
|
* 2 6 10 14
|
|
* 3 7 11 15
|
|
*
|
|
* @param mat An array containing 16 elements in column-major order.
|
|
*/
|
|
explicit Mat4(const float *mat);
|
|
|
|
/**
|
|
* Constructs a new matrix by copying the values from the specified matrix.
|
|
*
|
|
* @param copy The matrix to copy.
|
|
*/
|
|
Mat4(const Mat4 ©);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~Mat4() = default;
|
|
|
|
/**
|
|
* Creates a view matrix based on the specified input parameters.
|
|
*
|
|
* @param eyePosition The eye position.
|
|
* @param targetPosition The target's center position.
|
|
* @param up The up vector.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createLookAt(const Vec3 &eyePosition, const Vec3 &targetPosition, const Vec3 &up, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a view matrix based on the specified input parameters.
|
|
*
|
|
* @param eyePositionX The eye x-coordinate position.
|
|
* @param eyePositionY The eye y-coordinate position.
|
|
* @param eyePositionZ The eye z-coordinate position.
|
|
* @param targetCenterX The target's center x-coordinate position.
|
|
* @param targetCenterY The target's center y-coordinate position.
|
|
* @param targetCenterZ The target's center z-coordinate position.
|
|
* @param upX The up vector x-coordinate value.
|
|
* @param upY The up vector y-coordinate value.
|
|
* @param upZ The up vector z-coordinate value.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createLookAt(float eyePositionX, float eyePositionY, float eyePositionZ,
|
|
float targetPositionX, float targetPositionY, float targetPositionZ,
|
|
float upX, float upY, float upZ, Mat4 *dst);
|
|
|
|
/**
|
|
* Builds a perspective projection matrix based on a field of view and returns by value.
|
|
*
|
|
* Projection space refers to the space after applying projection transformation from view space.
|
|
* After the projection transformation, visible content has x- and y-coordinates ranging from -1 to 1,
|
|
* and a z-coordinate ranging from 0 to 1. To obtain the viewable area (in world space) of a scene,
|
|
* create a BoundingFrustum and pass the combined view and projection matrix to the constructor.
|
|
*
|
|
* @param fieldOfView The field of view in the y direction (in degrees).
|
|
* @param aspectRatio The aspect ratio, defined as view space width divided by height.
|
|
* @param zNearPlane The distance to the near view plane.
|
|
* @param zFarPlane The distance to the far view plane.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createPerspective(float fieldOfView, float aspectRatio, float zNearPlane, float zFarPlane, Mat4 *dst = nullptr) {
|
|
Mat4::createPerspective(fieldOfView, aspectRatio, zNearPlane, zFarPlane, true, -1.0F, 1.0F, 0, dst);
|
|
}
|
|
|
|
static void createPerspective(float fieldOfView, float aspectRatio, float zNearPlane, float zFarPlane,
|
|
bool isFieldOfViewY = false, float minClipZ = -1, float projectionSignY = 1,
|
|
int orientation = 0, Mat4 *dst = nullptr);
|
|
|
|
/**
|
|
* Creates an orthographic projection matrix.
|
|
*
|
|
* Projection space refers to the space after applying
|
|
* projection transformation from view space. After the
|
|
* projection transformation, visible content has
|
|
* x and y coordinates ranging from -1 to 1, and z coordinates
|
|
* ranging from 0 to 1.
|
|
*
|
|
* Unlike perspective projection, in orthographic projection
|
|
* there is no perspective foreshortening.
|
|
*
|
|
* The viewable area of this orthographic projection extends
|
|
* from left to right on the x-axis, bottom to top on the y-axis,
|
|
* and zNearPlane to zFarPlane on the z-axis. These values are
|
|
* relative to the position and x, y, and z-axes of the view.
|
|
* To obtain the viewable area (in world space) of a scene,
|
|
* create a BoundingFrustum and pass the combined view and
|
|
* projection matrix to the constructor.
|
|
*
|
|
* @param left The minimum x-value of the view volume.
|
|
* @param right The maximum x-value of the view volume.
|
|
* @param bottom The minimum y-value of the view volume.
|
|
* @param top The maximum y-value of the view volume.
|
|
* @param zNearPlane The minimum z-value of the view volume.
|
|
* @param zFarPlane The maximum z-value of the view volume.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createOrthographic(float left, float right, float bottom, float top, float zNearPlane, float zFarPlane, Mat4 *dst);
|
|
|
|
static void createOrthographicOffCenter(float left, float right, float bottom, float top,
|
|
float zNearPlane, float zFarPlane, Mat4 *dst);
|
|
|
|
static void createOrthographicOffCenter(float left, float right, float bottom, float top,
|
|
float zNearPlane, float zFarPlane, float minClipZ,
|
|
float projectionSignY, int orientation, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a spherical billboard that rotates around a specified object position.
|
|
*
|
|
* This method computes the facing direction of the billboard from the object position
|
|
* and camera position. When the object and camera positions are too close, the matrix
|
|
* will not be accurate. To avoid this problem, this method defaults to the identity
|
|
* rotation if the positions are too close. (See the other overload of createBillboard
|
|
* for an alternative approach).
|
|
*
|
|
* @param objectPosition The position of the object the billboard will rotate around.
|
|
* @param cameraPosition The position of the camera.
|
|
* @param cameraUpVector The up vector of the camera.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createBillboard(const Vec3 &objectPosition, const Vec3 &cameraPosition,
|
|
const Vec3 &cameraUpVector, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a spherical billboard that rotates around a specified object position with
|
|
* provision for a safe default orientation.
|
|
*
|
|
* This method computes the facing direction of the billboard from the object position
|
|
* and camera position. When the object and camera positions are too close, the matrix
|
|
* will not be accurate. To avoid this problem, this method uses the specified camera
|
|
* forward vector if the positions are too close. (See the other overload of createBillboard
|
|
* for an alternative approach).
|
|
*
|
|
* @param objectPosition The position of the object the billboard will rotate around.
|
|
* @param cameraPosition The position of the camera.
|
|
* @param cameraUpVector The up vector of the camera.
|
|
* @param cameraForwardVector The forward vector of the camera, used if the positions are too close.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createBillboard(const Vec3 &objectPosition, const Vec3 &cameraPosition,
|
|
const Vec3 &cameraUpVector, const Vec3 &cameraForwardVector,
|
|
Mat4 *dst);
|
|
|
|
//Fills in an existing Mat4 so that it reflects the coordinate system about a specified Plane.
|
|
//plane The Plane about which to create a reflection.
|
|
//dst A matrix to store the result in.
|
|
//static void createReflection(const Plane& plane, Mat4* dst);
|
|
|
|
/**
|
|
* Creates a scale matrix.
|
|
*
|
|
* @param scale The amount to scale.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createScale(const Vec3 &scale, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a scale matrix.
|
|
*
|
|
* @param xScale The amount to scale along the x-axis.
|
|
* @param yScale The amount to scale along the y-axis.
|
|
* @param zScale The amount to scale along the z-axis.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createScale(float xScale, float yScale, float zScale, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a rotation matrix from the specified quaternion.
|
|
*
|
|
* @param quat A quaternion describing a 3D orientation.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createRotation(const Quaternion &quat, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a rotation matrix from the specified axis and angle.
|
|
*
|
|
* @param axis A vector describing the axis to rotate about.
|
|
* @param angle The angle (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createRotation(const Vec3 &axis, float angle, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a matrix describing a rotation around the x-axis.
|
|
*
|
|
* @param angle The angle of rotation (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createRotationX(float angle, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a matrix describing a rotation around the y-axis.
|
|
*
|
|
* @param angle The angle of rotation (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createRotationY(float angle, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a matrix describing a rotation around the z-axis.
|
|
*
|
|
* @param angle The angle of rotation (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createRotationZ(float angle, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a translation matrix.
|
|
*
|
|
* @param translation The translation.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createTranslation(const Vec3 &translation, Mat4 *dst);
|
|
|
|
/**
|
|
* Creates a translation matrix.
|
|
*
|
|
* @param xTranslation The translation on the x-axis.
|
|
* @param yTranslation The translation on the y-axis.
|
|
* @param zTranslation The translation on the z-axis.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void createTranslation(float xTranslation, float yTranslation, float zTranslation, Mat4 *dst);
|
|
|
|
/**
|
|
* Adds a scalar value to each component of this matrix.
|
|
*
|
|
* @param scalar The scalar to add.
|
|
*/
|
|
void add(float scalar);
|
|
|
|
/**
|
|
* Adds a scalar value to each component of this matrix and stores the result in dst.
|
|
*
|
|
* @param scalar The scalar value to add.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void add(float scalar, Mat4 *dst);
|
|
|
|
/**
|
|
* Adds the specified matrix to this matrix.
|
|
*
|
|
* @param mat The matrix to add.
|
|
*/
|
|
void add(const Mat4 &mat);
|
|
|
|
/**
|
|
* Adds the specified matrices and stores the result in dst.
|
|
*
|
|
* @param m1 The first matrix.
|
|
* @param m2 The second matrix.
|
|
* @param dst The destination matrix to add to.
|
|
*/
|
|
static void add(const Mat4 &m1, const Mat4 &m2, Mat4 *dst);
|
|
|
|
/**
|
|
* Calculate the matrix according to the ratation and translation
|
|
*/
|
|
static void fromRT(const Quaternion &rotation, const Vec3 &translation, Mat4 *dst);
|
|
|
|
/**
|
|
* Compose a matrix from scale, rotation and translation, applied in order.
|
|
*/
|
|
static void fromRTS(const Quaternion &rotation, const Vec3 &translation, const Vec3 &scale, Mat4 *dst);
|
|
|
|
/**
|
|
* Decomposes the scale, rotation and translation components of this matrix.
|
|
*/
|
|
static void toRTS(const Mat4 &src, Quaternion *rotation, Vec3 *translation, Vec3 *scale);
|
|
|
|
/**
|
|
* Decomposes the scale, rotation and translation components of this matrix.
|
|
*
|
|
* @param scale The scale.
|
|
* @param rotation The rotation.
|
|
* @param translation The translation.
|
|
*/
|
|
bool decompose(Vec3 *scale, Quaternion *rotation, Vec3 *translation) const;
|
|
|
|
/**
|
|
* Computes the determinant of this matrix.
|
|
*
|
|
* @return The determinant.
|
|
*/
|
|
float determinant() const;
|
|
|
|
/**
|
|
* Gets the scalar component of this matrix in the specified vector.
|
|
*
|
|
* If the scalar component of this matrix has negative parts,
|
|
* it is not possible to always extract the exact scalar component;
|
|
* instead, a scale vector that is mathematically equivalent to the
|
|
* original scale vector is extracted and returned.
|
|
*
|
|
* @param scale A vector to receive the scale.
|
|
*/
|
|
void getScale(Vec3 *scale) const;
|
|
|
|
/**
|
|
* Gets the rotational component of this matrix in the specified quaternion.
|
|
*
|
|
* @param rotation A quaternion to receive the rotation.
|
|
*
|
|
* @return true if the rotation is successfully extracted, false otherwise.
|
|
*/
|
|
bool getRotation(Quaternion *rotation) const;
|
|
|
|
/**
|
|
* Gets the translational component of this matrix in the specified vector.
|
|
*
|
|
* @param translation A vector to receive the translation.
|
|
*/
|
|
void getTranslation(Vec3 *translation) const;
|
|
|
|
/**
|
|
* Gets the up vector of this matrix.
|
|
*
|
|
* @param dst The destination vector.
|
|
*/
|
|
void getUpVector(Vec3 *dst) const;
|
|
|
|
/**
|
|
* Gets the down vector of this matrix.
|
|
*
|
|
* @param dst The destination vector.
|
|
*/
|
|
void getDownVector(Vec3 *dst) const;
|
|
|
|
/**
|
|
* Gets the left vector of this matrix.
|
|
*
|
|
* @param dst The destination vector.
|
|
*/
|
|
void getLeftVector(Vec3 *dst) const;
|
|
|
|
/**
|
|
* Gets the right vector of this matrix.
|
|
*
|
|
* @param dst The destination vector.
|
|
*/
|
|
void getRightVector(Vec3 *dst) const;
|
|
|
|
/**
|
|
* Gets the forward vector of this matrix.
|
|
*
|
|
* @param dst The destination vector.
|
|
*/
|
|
void getForwardVector(Vec3 *dst) const;
|
|
|
|
/**
|
|
* Gets the backward vector of this matrix.
|
|
*
|
|
* @param dst The destination vector.
|
|
*/
|
|
void getBackVector(Vec3 *dst) const;
|
|
|
|
/**
|
|
* Inverts this matrix.
|
|
*
|
|
* @return true if the matrix can be inverted, false otherwise.
|
|
*/
|
|
bool inverse();
|
|
|
|
/**
|
|
* Clone this matrix.
|
|
*
|
|
* @return a new clone matrix.
|
|
*/
|
|
Mat4 clone() const;
|
|
|
|
/**
|
|
* Get the inversed matrix.
|
|
*/
|
|
Mat4 getInversed() const;
|
|
|
|
/**
|
|
* Determines if this matrix is equal to the identity matrix.
|
|
*
|
|
* @return true if the matrix is an identity matrix, false otherwise.
|
|
*/
|
|
bool isIdentity() const;
|
|
|
|
/**
|
|
* Multiplies the components of this matrix by the specified scalar.
|
|
*
|
|
* @param scalar The scalar value.
|
|
*/
|
|
void multiply(float scalar);
|
|
|
|
/**
|
|
* Multiplies the components of this matrix by a scalar and stores the result in dst.
|
|
*
|
|
* @param scalar The scalar value.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void multiply(float scalar, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Multiplies the components of the specified matrix by a scalar and stores the result in dst.
|
|
*
|
|
* @param mat The matrix.
|
|
* @param scalar The scalar value.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void multiply(const Mat4 &mat, float scalar, Mat4 *dst);
|
|
|
|
/**
|
|
* Multiplies this matrix by the specified one.
|
|
*
|
|
* @param mat The matrix to multiply.
|
|
*/
|
|
void multiply(const Mat4 &mat);
|
|
|
|
/**
|
|
* Multiplies m1 by m2 and stores the result in dst.
|
|
*
|
|
* @param m1 The first matrix to multiply.
|
|
* @param m2 The second matrix to multiply.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void multiply(const Mat4 &m1, const Mat4 &m2, Mat4 *dst);
|
|
|
|
/**
|
|
* Negates this matrix.
|
|
*/
|
|
void negate();
|
|
|
|
/**
|
|
Get the Negated matrix.
|
|
*/
|
|
Mat4 getNegated() const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified quaternion rotation.
|
|
*
|
|
* @param q The quaternion to rotate by.
|
|
*/
|
|
void rotate(const Quaternion &q);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified quaternion rotation and stores the result in dst.
|
|
*
|
|
* @param q The quaternion to rotate by.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void rotate(const Quaternion &q, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified rotation about the specified axis.
|
|
*
|
|
* @param axis The axis to rotate about.
|
|
* @param angle The angle (in radians).
|
|
*/
|
|
void rotate(const Vec3 &axis, float angle);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the specified
|
|
* rotation about the specified axis and stores the result in dst.
|
|
*
|
|
* @param axis The axis to rotate about.
|
|
* @param angle The angle (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void rotate(const Vec3 &axis, float angle, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified rotation around the x-axis.
|
|
*
|
|
* @param angle The angle (in radians).
|
|
*/
|
|
void rotateX(float angle);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified rotation around the x-axis and stores the result in dst.
|
|
*
|
|
* @param angle The angle (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void rotateX(float angle, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified rotation around the y-axis.
|
|
*
|
|
* @param angle The angle (in radians).
|
|
*/
|
|
void rotateY(float angle);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified rotation around the y-axis and stores the result in dst.
|
|
*
|
|
* @param angle The angle (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void rotateY(float angle, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified rotation around the z-axis.
|
|
*
|
|
* @param angle The angle (in radians).
|
|
*/
|
|
void rotateZ(float angle);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified rotation around the z-axis and stores the result in dst.
|
|
*
|
|
* @param angle The angle (in radians).
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void rotateZ(float angle, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified scale transformation.
|
|
*
|
|
* @param value The amount to scale along all axes.
|
|
*/
|
|
void scale(float value);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified scale transformation and stores the result in dst.
|
|
*
|
|
* @param value The amount to scale along all axes.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void scale(float value, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified scale transformation.
|
|
*
|
|
* @param xScale The amount to scale along the x-axis.
|
|
* @param yScale The amount to scale along the y-axis.
|
|
* @param zScale The amount to scale along the z-axis.
|
|
*/
|
|
void scale(float xScale, float yScale, float zScale);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified scale transformation and stores the result in dst.
|
|
*
|
|
* @param xScale The amount to scale along the x-axis.
|
|
* @param yScale The amount to scale along the y-axis.
|
|
* @param zScale The amount to scale along the z-axis.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void scale(float xScale, float yScale, float zScale, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified scale transformation.
|
|
*
|
|
* @param s The scale values along the x, y and z axes.
|
|
*/
|
|
void scale(const Vec3 &s);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified scale transformation and stores the result in dst.
|
|
*
|
|
* @param s The scale values along the x, y and z axes.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void scale(const Vec3 &s, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Sets the values of this matrix.
|
|
*
|
|
* @param m00 Component in column 0, row 0 position (index 0)
|
|
* @param m01 Component in column 0, row 1 position (index 1)
|
|
* @param m02 Component in column 0, row 2 position (index 2)
|
|
* @param m03 Component in column 0, row 3 position (index 3)
|
|
* @param m10 Component in column 1, row 0 position (index 4)
|
|
* @param m11 Component in column 1, row 1 position (index 5)
|
|
* @param m12 Component in column 1, row 2 position (index 6)
|
|
* @param m13 Component in column 1, row 3 position (index 7)
|
|
* @param m20 Component in column 2, row 0 position (index 8)
|
|
* @param m21 Component in column 2, row 1 position (index 9)
|
|
* @param m22 Component in column 2, row 2 position (index 10)
|
|
* @param m23 Component in column 2, row 3 position (index 11)
|
|
* @param m30 Component in column 3, row 0 position (index 12)
|
|
* @param m31 Component in column 3, row 1 position (index 13)
|
|
* @param m32 Component in column 3, row 2 position (index 14)
|
|
* @param m33 Component in column 3, row 3 position (index 15)
|
|
*/
|
|
void set(float m00, float m01, float m02, float m03,
|
|
float m10, float m11, float m12, float m13,
|
|
float m20, float m21, float m22, float m23,
|
|
float m30, float m31, float m32, float m33);
|
|
|
|
/**
|
|
* Sets the values of this matrix to those in the specified column-major array.
|
|
*
|
|
* @param mat An array containing 16 elements in column-major format.
|
|
*/
|
|
void set(const float *mat);
|
|
|
|
/**
|
|
* Sets the values of this matrix to those of the specified matrix.
|
|
*
|
|
* @param mat The source matrix.
|
|
*/
|
|
void set(const Mat4 &mat);
|
|
|
|
/**
|
|
* Sets this matrix to the identity matrix.
|
|
*/
|
|
void setIdentity();
|
|
|
|
/**
|
|
* Sets all elements of the current matrix to zero.
|
|
*/
|
|
void setZero();
|
|
|
|
/**
|
|
* Subtracts the specified matrix from the current matrix.
|
|
*
|
|
* @param mat The matrix to subtract.
|
|
*/
|
|
void subtract(const Mat4 &mat);
|
|
|
|
/**
|
|
* Subtracts the specified matrix from the current matrix.
|
|
*
|
|
* @param m1 The first matrix.
|
|
* @param m2 The second matrix.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
static void subtract(const Mat4 &m1, const Mat4 &m2, Mat4 *dst);
|
|
|
|
/**
|
|
* Transforms the specified vector by this matrix.
|
|
*
|
|
* The result of the transformation is stored directly into vector.
|
|
*
|
|
* @param vector The vector to transform.
|
|
*/
|
|
void transformVector(Vec4 *vector) const;
|
|
|
|
/**
|
|
* Transforms the specified vector by this matrix.
|
|
*
|
|
* @param vector The vector to transform.
|
|
* @param dst A vector to store the transformed point in.
|
|
*/
|
|
void transformVector(const Vec4 &vector, Vec4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified translation.
|
|
*
|
|
* @param x The amount to translate along the x-axis.
|
|
* @param y The amount to translate along the y-axis.
|
|
* @param z The amount to translate along the z-axis.
|
|
*/
|
|
void translate(float x, float y, float z);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified translation and stores the result in dst.
|
|
*
|
|
* @param x The amount to translate along the x-axis.
|
|
* @param y The amount to translate along the y-axis.
|
|
* @param z The amount to translate along the z-axis.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void translate(float x, float y, float z, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified translation.
|
|
*
|
|
* @param t The translation values along the x, y and z axes.
|
|
*/
|
|
void translate(const Vec3 &t);
|
|
|
|
/**
|
|
* Post-multiplies this matrix by the matrix corresponding to the
|
|
* specified translation and stores the result in dst.
|
|
*
|
|
* @param t The translation values along the x, y and z axes.
|
|
* @param dst A matrix to store the result in.
|
|
*/
|
|
void translate(const Vec3 &t, Mat4 *dst) const;
|
|
|
|
/**
|
|
* Transposes this matrix.
|
|
*/
|
|
void transpose();
|
|
|
|
/**
|
|
* Get the Transposed matrix.
|
|
*/
|
|
Mat4 getTransposed() const;
|
|
|
|
/**
|
|
* Calculates the inverse transpose of a matrix and save the results to out matrix
|
|
*/
|
|
static void inverseTranspose(const Mat4 &mat, Mat4 *dst);
|
|
/**
|
|
* Calculates the sum of this matrix with the given matrix.
|
|
*
|
|
* Note: this does not modify this matrix.
|
|
*
|
|
* @param mat The matrix to add.
|
|
* @return The matrix sum.
|
|
*/
|
|
inline const Mat4 operator+(const Mat4 &mat) const;
|
|
|
|
/**
|
|
* Adds the given matrix to this matrix.
|
|
*
|
|
* @param mat The matrix to add.
|
|
* @return This matrix, after the addition occurs.
|
|
*/
|
|
inline Mat4 &operator+=(const Mat4 &mat);
|
|
|
|
/**
|
|
* Calculates the difference of this matrix with the given matrix.
|
|
*
|
|
* Note: this does not modify this matrix.
|
|
*
|
|
* @param mat The matrix to subtract.
|
|
* @return The matrix difference.
|
|
*/
|
|
inline const Mat4 operator-(const Mat4 &mat) const;
|
|
|
|
/**
|
|
* Subtracts the given matrix from this matrix.
|
|
*
|
|
* @param mat The matrix to subtract.
|
|
* @return This matrix, after the subtraction occurs.
|
|
*/
|
|
inline Mat4 &operator-=(const Mat4 &mat);
|
|
|
|
/**
|
|
* Calculates the negation of this matrix.
|
|
*
|
|
* Note: this does not modify this matrix.
|
|
*
|
|
* @return The negation of this matrix.
|
|
*/
|
|
inline const Mat4 operator-() const;
|
|
|
|
/**
|
|
* Calculates the matrix product of this matrix with the given matrix.
|
|
*
|
|
* Note: this does not modify this matrix.
|
|
*
|
|
* @param mat The matrix to multiply by.
|
|
* @return The matrix product.
|
|
*/
|
|
inline const Mat4 operator*(const Mat4 &mat) const;
|
|
|
|
/**
|
|
* Right-multiplies this matrix by the given matrix.
|
|
*
|
|
* @param mat The matrix to multiply by.
|
|
* @return This matrix, after the multiplication occurs.
|
|
*/
|
|
inline Mat4 &operator*=(const Mat4 &mat);
|
|
|
|
/**
|
|
* Determines if this matrix is approximately equal to the given matrix.
|
|
*/
|
|
bool approxEquals(const Mat4 &v, float precision = CC_FLOAT_CMP_PRECISION) const;
|
|
|
|
/** equals to a matrix full of zeros */
|
|
static const Mat4 ZERO;
|
|
/** equals to the identity matrix */
|
|
static const Mat4 IDENTITY;
|
|
|
|
private:
|
|
static void createBillboardHelper(const Vec3 &objectPosition, const Vec3 &cameraPosition,
|
|
const Vec3 &cameraUpVector, const Vec3 *cameraForwardVector,
|
|
Mat4 *dst);
|
|
};
|
|
|
|
/**
|
|
* Transforms the given vector by the given matrix.
|
|
*
|
|
* Note: this treats the given vector as a vector and not as a point.
|
|
*
|
|
* @param v The vector to transform.
|
|
* @param m The matrix to transform by.
|
|
* @return This vector, after the transformation occurs.
|
|
*/
|
|
inline Vec4 &operator*=(Vec4 &v, const Mat4 &m);
|
|
|
|
/**
|
|
* Transforms the given vector by the given matrix.
|
|
*
|
|
* Note: this treats the given vector as a vector and not as a point.
|
|
*
|
|
* @param m The matrix to transform by.
|
|
* @param v The vector to transform.
|
|
* @return The resulting transformed vector.
|
|
*/
|
|
inline const Vec4 operator*(const Mat4 &m, const Vec4 &v);
|
|
|
|
NS_CC_MATH_END
|
|
/**
|
|
end of base group
|
|
@}
|
|
*/
|
|
#include "math/Mat4.inl"
|
|
|