Matrix4x3d

Contains the definition of an affine 4x3 matrix (4 columns, 3 rows) of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this: <p> m00 m10 m20 m30<br> m01 m11 m21 m31<br> m02 m12 m22 m32<br>

@author Richard Greenlees @author Kai Burjack

struct Matrix4x3d {

immutable static

int PLANE_NX;

immutable static

int PLANE_PX;

immutable static

int PLANE_NY;

immutable static

int PLANE_PY;

immutable static

int PLANE_NZ;

immutable static

int PLANE_PZ;

immutable static

byte PROPERTY_IDENTITY;

immutable static

byte PROPERTY_TRANSLATION;

immutable static

byte PROPERTY_ORTHONORMAL;

int properties;

this(Matrix4x3d mat);

this(Matrix3d mat);

this(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32);

Matrix4x3d assume(int properties);

Matrix4x3d determineProperties();

int getproperties();

Matrix4x3d _properties(int properties);

Matrix4x3d _m00(double m00);

Matrix4x3d _m01(double m01);

Matrix4x3d _m02(double m02);

Matrix4x3d _m10(double m10);

Matrix4x3d _m11(double m11);

Matrix4x3d _m12(double m12);

Matrix4x3d _m20(double m20);

Matrix4x3d _m21(double m21);

Matrix4x3d _m22(double m22);

Matrix4x3d _m30(double m30);

Matrix4x3d _m31(double m31);

Matrix4x3d _m32(double m32);

Matrix4x3d setm00(double m00);

Matrix4x3d setm01(double m01);

Matrix4x3d setm02(double m02);

Matrix4x3d setm10(double m10);

Matrix4x3d setm11(double m11);

Matrix4x3d setm12(double m12);

Matrix4x3d setm20(double m20);

Matrix4x3d setm21(double m21);

Matrix4x3d setm22(double m22);

Matrix4x3d setm30(double m30);

Matrix4x3d setm31(double m31);

Matrix4x3d setm32(double m32);

Matrix4x3d identity();

Matrix4x3d set(Matrix4x3d m);

Matrix4x3d set(Matrix4d m);

Matrix4d get(Matrix4d dest);

Matrix4x3d set(Matrix3d mat);

Matrix4x3d set(Vector3d col0, Vector3d col1, Vector3d col2, Vector3d col3);

Matrix4x3d set3x3(Matrix4x3d mat);

Matrix4x3d set(AxisAngle4d axisAngle);

Matrix4x3d set(Quaterniond q);

Matrix4x3d mul(Matrix4x3d right);

Matrix4x3d mul(Matrix4x3d right, Matrix4x3d dest);

Matrix4x3d mulTranslation(Matrix4x3d right, Matrix4x3d dest);

Matrix4x3d mulOrtho(Matrix4x3d view);

Matrix4x3d mulOrtho(Matrix4x3d view, Matrix4x3d dest);

Matrix4x3d mul3x3(double rm00, double rm01, double rm02, double rm10, double rm11, double rm12, double rm20, double rm21, double rm22);

Matrix4x3d mul3x3(double rm00, double rm01, double rm02, double rm10, double rm11, double rm12, double rm20, double rm21, double rm22, Matrix4x3d dest);

Matrix4x3d fma(Matrix4x3d other, double otherFactor);

Matrix4x3d fma(Matrix4x3d other, double otherFactor, Matrix4x3d dest);

Matrix4x3d add(Matrix4x3d other);

Matrix4x3d add(Matrix4x3d other, Matrix4x3d dest);

Matrix4x3d sub(Matrix4x3d subtrahend);

Matrix4x3d sub(Matrix4x3d subtrahend, Matrix4x3d dest);

Matrix4x3d mulComponentWise(Matrix4x3d other);

Matrix4x3d mulComponentWise(Matrix4x3d other, Matrix4x3d dest);

Matrix4x3d set(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32);

Matrix4x3d set(double[] m, int off);

Matrix4x3d set(double[] m);

Matrix4x3d set(float[] m, int off);

Matrix4x3d set(float[] m);

double determinant();

Matrix4x3d invert();

Matrix4x3d invert(Matrix4x3d dest);

Matrix4x3d invertOrtho(Matrix4x3d dest);

Matrix4x3d invertOrtho();

Matrix4x3d transpose3x3();

Matrix4x3d transpose3x3(Matrix4x3d dest);

Matrix3d transpose3x3(Matrix3d dest);

Matrix4x3d translation(double x, double y, double z);

Matrix4x3d translation(Vector3d offset);

Matrix4x3d setTranslation(double x, double y, double z);

Matrix4x3d setTranslation(Vector3d xyz);

Vector3d getTranslation(Vector3d dest);

Vector3d getScale(Vector3d dest);

Matrix4x3d get(Matrix4x3d dest);

Quaterniond getUnnormalizedRotation(Quaterniond dest);

Quaterniond getNormalizedRotation(Quaterniond dest);

double[] get(double[] arr, int offset);

double[] get(double[] arr);

float[] get(float[] arr, int offset);

float[] get(float[] arr);

double[] get4x4(double[] arr, int offset);

double[] get4x4(double[] arr);

double[] getTransposed(double[] arr, int offset);

double[] getTransposed(double[] arr);

Matrix4x3d zero();

Matrix4x3d scaling(double factor);

Matrix4x3d scaling(double x, double y, double z);

Matrix4x3d scaling(Vector3d xyz);

Matrix4x3d rotation(double angle, double x, double y, double z);

Matrix4x3d rotationX(double ang);

Matrix4x3d rotationY(double ang);

Matrix4x3d rotationZ(double ang);

Matrix4x3d rotationXYZ(double angleX, double angleY, double angleZ);

Matrix4x3d rotationZYX(double angleZ, double angleY, double angleX);

Matrix4x3d rotationYXZ(double angleY, double angleX, double angleZ);

Matrix4x3d setRotationXYZ(double angleX, double angleY, double angleZ);

Matrix4x3d setRotationZYX(double angleZ, double angleY, double angleX);

Matrix4x3d setRotationYXZ(double angleY, double angleX, double angleZ);

Matrix4x3d rotation(double angle, Vector3d axis);

Vector4d transform(Vector4d v);

Vector4d transform(Vector4d v, Vector4d dest);

Vector3d transformPosition(Vector3d v);

Vector3d transformPosition(Vector3d v, Vector3d dest);

Vector3d transformDirection(Vector3d v);

Vector3d transformDirection(Vector3d v, Vector3d dest);

Matrix4x3d set3x3(Matrix3d mat);

Matrix4x3d scale(Vector3d xyz, Matrix4x3d dest);

Matrix4x3d scale(Vector3d xyz);

Matrix4x3d scale(double x, double y, double z, Matrix4x3d dest);

Matrix4x3d scale(double x, double y, double z);

Matrix4x3d scale(double xyz, Matrix4x3d dest);

Matrix4x3d scale(double xyz);

Matrix4x3d scaleXY(double x, double y, Matrix4x3d dest);

Matrix4x3d scaleXY(double x, double y);

Matrix4x3d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4x3d dest);

Matrix4x3d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz);

Matrix4x3d scaleAround(double factor, double ox, double oy, double oz);

Matrix4x3d scaleAround(double factor, double ox, double oy, double oz, Matrix4x3d dest);

Matrix4x3d scaleLocal(double x, double y, double z, Matrix4x3d dest);

Matrix4x3d scaleLocal(double x, double y, double z);

Matrix4x3d rotate(double ang, double x, double y, double z, Matrix4x3d dest);

Matrix4x3d rotate(double ang, double x, double y, double z);

Matrix4x3d rotateTranslation(double ang, double x, double y, double z, Matrix4x3d dest);

Matrix4x3d rotateAround(Quaterniond quat, double ox, double oy, double oz);

Matrix4x3d rotateAround(Quaterniond quat, double ox, double oy, double oz, Matrix4x3d dest);

Matrix4x3d rotationAround(Quaterniond quat, double ox, double oy, double oz);

Matrix4x3d rotateLocal(double ang, double x, double y, double z, Matrix4x3d dest);

Matrix4x3d rotateLocal(double ang, double x, double y, double z);

Matrix4x3d rotateLocalX(double ang, Matrix4x3d dest);

Matrix4x3d rotateLocalX(double ang);

Matrix4x3d rotateLocalY(double ang, Matrix4x3d dest);

Matrix4x3d rotateLocalY(double ang);

Matrix4x3d rotateLocalZ(double ang, Matrix4x3d dest);

Matrix4x3d rotateLocalZ(double ang);

Matrix4x3d translate(Vector3d offset);

Matrix4x3d translate(Vector3d offset, Matrix4x3d dest);

Matrix4x3d translate(double x, double y, double z, Matrix4x3d dest);

Matrix4x3d translate(double x, double y, double z);

Matrix4x3d translateLocal(Vector3d offset);

Matrix4x3d translateLocal(Vector3d offset, Matrix4x3d dest);

Matrix4x3d translateLocal(double x, double y, double z, Matrix4x3d dest);

Matrix4x3d translateLocal(double x, double y, double z);

Matrix4x3d rotateX(double ang, Matrix4x3d dest);

Matrix4x3d rotateX(double ang);

Matrix4x3d rotateY(double ang, Matrix4x3d dest);

Matrix4x3d rotateY(double ang);

Matrix4x3d rotateZ(double ang, Matrix4x3d dest);

Matrix4x3d rotateZ(double ang);

Matrix4x3d rotateXYZ(Vector3d angles);

Matrix4x3d rotateXYZ(double angleX, double angleY, double angleZ);

Matrix4x3d rotateXYZ(double angleX, double angleY, double angleZ, Matrix4x3d dest);

Matrix4x3d rotateZYX(Vector3d angles);

Matrix4x3d rotateZYX(double angleZ, double angleY, double angleX);

Matrix4x3d rotateZYX(double angleZ, double angleY, double angleX, Matrix4x3d dest);

Matrix4x3d rotateYXZ(Vector3d angles);

Matrix4x3d rotateYXZ(double angleY, double angleX, double angleZ);

Matrix4x3d rotateYXZ(double angleY, double angleX, double angleZ, Matrix4x3d dest);

Matrix4x3d rotation(AxisAngle4d angleAxis);

Matrix4x3d rotation(Quaterniond quat);

Matrix4x3d translationRotateScale(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz);

Matrix4x3d translationRotateScale(Vector3d translation, Quaterniond quat, Vector3d scale);

Matrix4x3d translationRotateScaleMul(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz, Matrix4x3d m);

Matrix4x3d translationRotateScaleMul(Vector3d translation, Quaterniond quat, Vector3d scale, Matrix4x3d m);

Matrix4x3d translationRotate(double tx, double ty, double tz, Quaterniond quat);

Matrix4x3d translationRotate(double tx, double ty, double tz, double qx, double qy, double qz, double qw);

Matrix4x3d translationRotate(Vector3d translation, Quaterniond quat);

Matrix4x3d translationRotateMul(double tx, double ty, double tz, double qx, double qy, double qz, double qw, Matrix4x3d mat);

Matrix4x3d translationRotateInvert(double tx, double ty, double tz, double qx, double qy, double qz, double qw);

Matrix4x3d translationRotateInvert(Vector3d translation, Quaterniond quat);

Matrix4x3d rotate(Quaterniond quat, Matrix4x3d dest);

Matrix4x3d rotate(Quaterniond quat);

Matrix4x3d rotateTranslation(Quaterniond quat, Matrix4x3d dest);

Matrix4x3d rotateLocal(Quaterniond quat, Matrix4x3d dest);

Matrix4x3d rotateLocal(Quaterniond quat);

Matrix4x3d rotate(AxisAngle4d axisAngle);

Matrix4x3d rotate(AxisAngle4d axisAngle, Matrix4x3d dest);

Matrix4x3d rotate(double angle, Vector3d axis);

Matrix4x3d rotate(double angle, Vector3d axis, Matrix4x3d dest);

Vector4d getRow(int row, Vector4d dest);

Matrix4x3d setRow(int row, Vector4d src);

Vector3d getColumn(int column, Vector3d dest);

Matrix4x3d setColumn(int column, Vector3d src);

Matrix4x3d normal();

Matrix4x3d normal(Matrix4x3d dest);

Matrix3d normal(Matrix3d dest);

Matrix4x3d cofactor3x3();

Matrix3d cofactor3x3(Matrix3d dest);

Matrix4x3d cofactor3x3(Matrix4x3d dest);

Matrix4x3d normalize3x3();

Matrix4x3d normalize3x3(Matrix4x3d dest);

Matrix3d normalize3x3(Matrix3d dest);

Matrix4x3d reflect(double a, double b, double c, double d, Matrix4x3d dest);

Matrix4x3d reflect(double a, double b, double c, double d);

Matrix4x3d reflect(double nx, double ny, double nz, double px, double py, double pz);

Matrix4x3d reflect(double nx, double ny, double nz, double px, double py, double pz, Matrix4x3d dest);

Matrix4x3d reflect(Vector3d normal, Vector3d point);

Matrix4x3d reflect(Quaterniond orientation, Vector3d point);

Matrix4x3d reflect(Quaterniond orientation, Vector3d point, Matrix4x3d dest);

Matrix4x3d reflect(Vector3d normal, Vector3d point, Matrix4x3d dest);

Matrix4x3d reflection(double a, double b, double c, double d);

Matrix4x3d reflection(double nx, double ny, double nz, double px, double py, double pz);

Matrix4x3d reflection(Vector3d normal, Vector3d point);

Matrix4x3d reflection(Quaterniond orientation, Vector3d point);

Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest);

Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest);

Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest);

Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest);

Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4x3d setOrtho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d setOrtho(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4x3d setOrthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d setOrthoLH(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest);

Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, Matrix4x3d dest);

Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar);

Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest);

Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, Matrix4x3d dest);

Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar);

Matrix4x3d setOrthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d setOrthoSymmetric(double width, double height, double zNear, double zFar);

Matrix4x3d setOrthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne);

Matrix4x3d setOrthoSymmetricLH(double width, double height, double zNear, double zFar);

Matrix4x3d ortho2D(double left, double right, double bottom, double top, Matrix4x3d dest);

Matrix4x3d ortho2D(double left, double right, double bottom, double top);

Matrix4x3d ortho2DLH(double left, double right, double bottom, double top, Matrix4x3d dest);

Matrix4x3d ortho2DLH(double left, double right, double bottom, double top);

Matrix4x3d setOrtho2D(double left, double right, double bottom, double top);

Matrix4x3d setOrtho2DLH(double left, double right, double bottom, double top);

Matrix4x3d lookAlong(Vector3d dir, Vector3d up);

Matrix4x3d lookAlong(Vector3d dir, Vector3d up, Matrix4x3d dest);

Matrix4x3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest);

Matrix4x3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ);

Matrix4x3d setLookAlong(Vector3d dir, Vector3d up);

Matrix4x3d setLookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ);

Matrix4x3d setLookAt(Vector3d eye, Vector3d center, Vector3d up);

Matrix4x3d setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ);

Matrix4x3d lookAt(Vector3d eye, Vector3d center, Vector3d up, Matrix4x3d dest);

Matrix4x3d lookAt(Vector3d eye, Vector3d center, Vector3d up);

Matrix4x3d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest);

Matrix4x3d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ);

Matrix4x3d setLookAtLH(Vector3d eye, Vector3d center, Vector3d up);

Matrix4x3d setLookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ);

Matrix4x3d lookAtLH(Vector3d eye, Vector3d center, Vector3d up, Matrix4x3d dest);

Matrix4x3d lookAtLH(Vector3d eye, Vector3d center, Vector3d up);

Matrix4x3d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest);

Matrix4x3d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ);

Vector4d frustumPlane(int which, Vector4d dest);

Vector3d positiveZ(Vector3d dir);

Vector3d normalizedPositiveZ(Vector3d dir);

Vector3d positiveX(Vector3d dir);

Vector3d normalizedPositiveX(Vector3d dir);

Vector3d positiveY(Vector3d dir);

Vector3d normalizedPositiveY(Vector3d dir);

Vector3d origin(Vector3d origin);

Matrix4x3d shadow(Vector4d light, double a, double b, double c, double d);

Matrix4x3d shadow(Vector4d light, double a, double b, double c, double d, Matrix4x3d dest);

Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d);

Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d, Matrix4x3d dest);

Matrix4x3d shadow(Vector4d light, Matrix4x3d planeTransform, Matrix4x3d dest);

Matrix4x3d shadow(Vector4d light, Matrix4x3d planeTransform);

Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4x3d planeTransform, Matrix4x3d dest);

Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4x3d planeTransform);

Matrix4x3d billboardCylindrical(Vector3d objPos, Vector3d targetPos, Vector3d up);

Matrix4x3d billboardSpherical(Vector3d objPos, Vector3d targetPos, Vector3d up);

Matrix4x3d billboardSpherical(Vector3d objPos, Vector3d targetPos);

int hashCode();

bool equals(Matrix4x3d m, double delta);

Matrix4x3d pick(double x, double y, double width, double height, int[] viewport, Matrix4x3d dest);

Matrix4x3d pick(double x, double y, double width, double height, int[] viewport);

Matrix4x3d swap(Matrix4x3d other);

Matrix4x3d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY, Matrix4x3d dest);

Matrix4x3d arcball(double radius, Vector3d center, double angleX, double angleY, Matrix4x3d dest);

Matrix4x3d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY);

Matrix4x3d arcball(double radius, Vector3d center, double angleX, double angleY);

Matrix4x3d transformAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector3d outMin, Vector3d outMax);

Matrix4x3d transformAab(Vector3d min, Vector3d max, Vector3d outMin, Vector3d outMax);

Matrix4x3d lerp(Matrix4x3d other, double t);

Matrix4x3d lerp(Matrix4x3d other, double t, Matrix4x3d dest);

Matrix4x3d rotateTowards(Vector3d dir, Vector3d up, Matrix4x3d dest);

Matrix4x3d rotateTowards(Vector3d dir, Vector3d up);

Matrix4x3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ);

Matrix4x3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest);

Matrix4x3d rotationTowards(Vector3d dir, Vector3d up);

Matrix4x3d rotationTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ);

Matrix4x3d translationRotateTowards(Vector3d pos, Vector3d dir, Vector3d up);

Matrix4x3d translationRotateTowards(double posX, double posY, double posZ, double dirX, double dirY, double dirZ, double upX, double upY, double upZ);

Vector3d getEulerAnglesZYX(Vector3d dest);

Vector3d getEulerAnglesXYZ(Vector3d dest);

Matrix4x3d obliqueZ(double a, double b);

Matrix4x3d obliqueZ(double a, double b, Matrix4x3d dest);

Matrix4x3d mapXZY();

Matrix4x3d mapXZY(Matrix4x3d dest);

Matrix4x3d mapXZnY();

Matrix4x3d mapXZnY(Matrix4x3d dest);

Matrix4x3d mapXnYnZ();

Matrix4x3d mapXnYnZ(Matrix4x3d dest);

Matrix4x3d mapXnZY();

Matrix4x3d mapXnZY(Matrix4x3d dest);

Matrix4x3d mapXnZnY();

Matrix4x3d mapXnZnY(Matrix4x3d dest);

Matrix4x3d mapYXZ();

Matrix4x3d mapYXZ(Matrix4x3d dest);

Matrix4x3d mapYXnZ();

Matrix4x3d mapYXnZ(Matrix4x3d dest);

Matrix4x3d mapYZX();

Matrix4x3d mapYZX(Matrix4x3d dest);

Matrix4x3d mapYZnX();

Matrix4x3d mapYZnX(Matrix4x3d dest);

Matrix4x3d mapYnXZ();

Matrix4x3d mapYnXZ(Matrix4x3d dest);

Matrix4x3d mapYnXnZ();

Matrix4x3d mapYnXnZ(Matrix4x3d dest);

Matrix4x3d mapYnZX();

Matrix4x3d mapYnZX(Matrix4x3d dest);

Matrix4x3d mapYnZnX();

Matrix4x3d mapYnZnX(Matrix4x3d dest);

Matrix4x3d mapZXY();

Matrix4x3d mapZXY(Matrix4x3d dest);

Matrix4x3d mapZXnY();

Matrix4x3d mapZXnY(Matrix4x3d dest);

Matrix4x3d mapZYX();

Matrix4x3d mapZYX(Matrix4x3d dest);

Matrix4x3d mapZYnX();

Matrix4x3d mapZYnX(Matrix4x3d dest);

Matrix4x3d mapZnXY();

Matrix4x3d mapZnXY(Matrix4x3d dest);

Matrix4x3d mapZnXnY();

Matrix4x3d mapZnXnY(Matrix4x3d dest);

Matrix4x3d mapZnYX();

Matrix4x3d mapZnYX(Matrix4x3d dest);

Matrix4x3d mapZnYnX();

Matrix4x3d mapZnYnX(Matrix4x3d dest);

Matrix4x3d mapnXYnZ();

Matrix4x3d mapnXYnZ(Matrix4x3d dest);

Matrix4x3d mapnXZY();

Matrix4x3d mapnXZY(Matrix4x3d dest);

Matrix4x3d mapnXZnY();

Matrix4x3d mapnXZnY(Matrix4x3d dest);

Matrix4x3d mapnXnYZ();

Matrix4x3d mapnXnYZ(Matrix4x3d dest);

Matrix4x3d mapnXnYnZ();

Matrix4x3d mapnXnYnZ(Matrix4x3d dest);

Matrix4x3d mapnXnZY();

Matrix4x3d mapnXnZY(Matrix4x3d dest);

Matrix4x3d mapnXnZnY();

Matrix4x3d mapnXnZnY(Matrix4x3d dest);

Matrix4x3d mapnYXZ();

Matrix4x3d mapnYXZ(Matrix4x3d dest);

Matrix4x3d mapnYXnZ();

Matrix4x3d mapnYXnZ(Matrix4x3d dest);

Matrix4x3d mapnYZX();

Matrix4x3d mapnYZX(Matrix4x3d dest);

Matrix4x3d mapnYZnX();

Matrix4x3d mapnYZnX(Matrix4x3d dest);

Matrix4x3d mapnYnXZ();

Matrix4x3d mapnYnXZ(Matrix4x3d dest);

Matrix4x3d mapnYnXnZ();

Matrix4x3d mapnYnXnZ(Matrix4x3d dest);

Matrix4x3d mapnYnZX();

Matrix4x3d mapnYnZX(Matrix4x3d dest);

Matrix4x3d mapnYnZnX();

Matrix4x3d mapnYnZnX(Matrix4x3d dest);

Matrix4x3d mapnZXY();

Matrix4x3d mapnZXY(Matrix4x3d dest);

Matrix4x3d mapnZXnY();

Matrix4x3d mapnZXnY(Matrix4x3d dest);

Matrix4x3d mapnZYX();

Matrix4x3d mapnZYX(Matrix4x3d dest);

Matrix4x3d mapnZYnX();

Matrix4x3d mapnZYnX(Matrix4x3d dest);

Matrix4x3d mapnZnXY();

Matrix4x3d mapnZnXY(Matrix4x3d dest);

Matrix4x3d mapnZnXnY();

Matrix4x3d mapnZnXnY(Matrix4x3d dest);

Matrix4x3d mapnZnYX();

Matrix4x3d mapnZnYX(Matrix4x3d dest);

Matrix4x3d mapnZnYnX();

Matrix4x3d mapnZnYnX(Matrix4x3d dest);

Matrix4x3d negateX();

Matrix4x3d negateX(Matrix4x3d dest);

Matrix4x3d negateY();

Matrix4x3d negateY(Matrix4x3d dest);

Matrix4x3d negateZ();

Matrix4x3d negateZ(Matrix4x3d dest);

bool isFinite();

}

Constructors

this this(Matrix4x3d mat): Create a new {@link Matrix4x3d} and make it a copy of the given matrix.
this this(Matrix3d mat): Create a new {@link Matrix4x3d} by setting its left 3x3 submatrix to the values of the given {@link Matrix3d} and the rest to identity.
this this(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32): Create a new 4x4 matrix using the supplied double values.

Members

Functions

_m00 Matrix4x3d _m00(double m00): Set the value of the matrix element at column 0 and row 0 without updating the properties of the matrix.
_m01 Matrix4x3d _m01(double m01): Set the value of the matrix element at column 0 and row 1 without updating the properties of the matrix.
_m02 Matrix4x3d _m02(double m02): Set the value of the matrix element at column 0 and row 2 without updating the properties of the matrix.
_m10 Matrix4x3d _m10(double m10): Set the value of the matrix element at column 1 and row 0 without updating the properties of the matrix.
_m11 Matrix4x3d _m11(double m11): Set the value of the matrix element at column 1 and row 1 without updating the properties of the matrix.
_m12 Matrix4x3d _m12(double m12): Set the value of the matrix element at column 1 and row 2 without updating the properties of the matrix.
_m20 Matrix4x3d _m20(double m20): Set the value of the matrix element at column 2 and row 0 without updating the properties of the matrix.
_m21 Matrix4x3d _m21(double m21): Set the value of the matrix element at column 2 and row 1 without updating the properties of the matrix.
_m22 Matrix4x3d _m22(double m22): Set the value of the matrix element at column 2 and row 2 without updating the properties of the matrix.
_m30 Matrix4x3d _m30(double m30): Set the value of the matrix element at column 3 and row 0 without updating the properties of the matrix.
_m31 Matrix4x3d _m31(double m31): Set the value of the matrix element at column 3 and row 1 without updating the properties of the matrix.
_m32 Matrix4x3d _m32(double m32): Set the value of the matrix element at column 3 and row 2 without updating the properties of the matrix.
_properties Matrix4x3d _properties(int properties): Undocumented in source. Be warned that the author may not have intended to support it.
add Matrix4x3d add(Matrix4x3d other): Component-wise add <code>this</code> and <code>other</code>.
add Matrix4x3d add(Matrix4x3d other, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
arcball Matrix4x3d arcball(double radius, Vector3d center, double angleX, double angleY): Apply an arcball view transformation to this matrix with the given <code>radius</code> and <code>center</code> position of the arcball and the specified X and Y rotation angles. <p> This method is equivalent to calling: <code>translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-center.x, -center.y, -center.z)</code>
arcball Matrix4x3d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY): Apply an arcball view transformation to this matrix with the given <code>radius</code> and center <code>(centerX, centerY, centerZ)</code> position of the arcball and the specified X and Y rotation angles. <p> This method is equivalent to calling: <code>translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-centerX, -centerY, -centerZ)</code>
arcball Matrix4x3d arcball(double radius, Vector3d center, double angleX, double angleY, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
arcball Matrix4x3d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
assume Matrix4x3d assume(int properties): Assume the given properties about this matrix. <p> Use one or multiple of 0, {@link Matrix4x3d#PROPERTY_IDENTITY}, {@link Matrix4x3d#PROPERTY_TRANSLATION}, {@link Matrix4x3d#PROPERTY_ORTHONORMAL}.
billboardCylindrical Matrix4x3d billboardCylindrical(Vector3d objPos, Vector3d targetPos, Vector3d up): Set this matrix to a cylindrical billboard transformation that rotates the local +Z axis of a given object with position <code>objPos</code> towards a target position at <code>targetPos</code> while constraining a cylindrical rotation around the given <code>up</code> vector. <p> This method can be used to create the complete model transformation for a given object, including the translation of the object to its position <code>objPos</code>.
billboardSpherical Matrix4x3d billboardSpherical(Vector3d objPos, Vector3d targetPos): Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position <code>objPos</code> towards a target position at <code>targetPos</code> using a shortest arc rotation by not preserving any <i>up</i> vector of the object. <p> This method can be used to create the complete model transformation for a given object, including the translation of the object to its position <code>objPos</code>. <p> In order to specify an <i>up</i> vector which needs to be maintained when rotating the +Z axis of the object, use {@link #billboardSpherical(Vector3d, Vector3d, Vector3d)}.
billboardSpherical Matrix4x3d billboardSpherical(Vector3d objPos, Vector3d targetPos, Vector3d up): Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position <code>objPos</code> towards a target position at <code>targetPos</code>. <p> This method can be used to create the complete model transformation for a given object, including the translation of the object to its position <code>objPos</code>. <p> If preserving an <i>up</i> vector is not necessary when rotating the +Z axis, then a shortest arc rotation can be obtained using {@link #billboardSpherical(Vector3d, Vector3d)}.
cofactor3x3 Matrix4x3d cofactor3x3(): Compute the cofactor matrix of the left 3x3 submatrix of <code>this</code>. <p> The cofactor matrix can be used instead of {@link #normal()} to transform normals when the orientation of the normals with respect to the surface should be preserved.
cofactor3x3 Matrix4x3d cofactor3x3(Matrix4x3d dest): Compute the cofactor matrix of the left 3x3 submatrix of <code>this</code> and store it into <code>dest</code>. All other values of <code>dest</code> will be set to {@link #identity() identity}. <p> The cofactor matrix can be used instead of {@link #normal(Matrix4x3d)} to transform normals when the orientation of the normals with respect to the surface should be preserved.
cofactor3x3 Matrix3d cofactor3x3(Matrix3d dest): Compute the cofactor matrix of the left 3x3 submatrix of <code>this</code> and store it into <code>dest</code>. <p> The cofactor matrix can be used instead of {@link #normal(Matrix3d)} to transform normals when the orientation of the normals with respect to the surface should be preserved.
determinant double determinant(): Undocumented in source. Be warned that the author may not have intended to support it.
determineProperties Matrix4x3d determineProperties(): Compute and set the matrix properties returned by {@link #properties()} based on the current matrix element values.
equals bool equals(Matrix4x3d m, double delta): Undocumented in source. Be warned that the author may not have intended to support it.
fma Matrix4x3d fma(Matrix4x3d other, double otherFactor, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
fma Matrix4x3d fma(Matrix4x3d other, double otherFactor): Component-wise add <code>this</code> and <code>other</code> by first multiplying each component of <code>other</code> by <code>otherFactor</code> and adding that result to <code>this</code>. <p> The matrix <code>other</code> will not be changed.
frustumPlane Vector4d frustumPlane(int which, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
get float[] get(float[] arr): Undocumented in source. Be warned that the author may not have intended to support it.
get float[] get(float[] arr, int offset): Undocumented in source. Be warned that the author may not have intended to support it.
get double[] get(double[] arr): Undocumented in source. Be warned that the author may not have intended to support it.
get double[] get(double[] arr, int offset): Undocumented in source. Be warned that the author may not have intended to support it.
get Matrix4x3d get(Matrix4x3d dest): Get the current values of <code>this</code> matrix and store them into <code>dest</code>. <p> This is the reverse method of {@link #set(Matrix4x3d)} and allows to obtain intermediate calculation results when chaining multiple transformations.
get Matrix4d get(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
get4x4 double[] get4x4(double[] arr): Undocumented in source. Be warned that the author may not have intended to support it.
get4x4 double[] get4x4(double[] arr, int offset): Undocumented in source. Be warned that the author may not have intended to support it.
getColumn Vector3d getColumn(int column, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
getEulerAnglesXYZ Vector3d getEulerAnglesXYZ(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
getEulerAnglesZYX Vector3d getEulerAnglesZYX(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
getNormalizedRotation Quaterniond getNormalizedRotation(Quaterniond dest): Undocumented in source. Be warned that the author may not have intended to support it.
getRow Vector4d getRow(int row, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
getScale Vector3d getScale(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
getTranslation Vector3d getTranslation(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
getTransposed double[] getTransposed(double[] arr): Undocumented in source. Be warned that the author may not have intended to support it.
getTransposed double[] getTransposed(double[] arr, int offset): Undocumented in source. Be warned that the author may not have intended to support it.
getUnnormalizedRotation Quaterniond getUnnormalizedRotation(Quaterniond dest): Undocumented in source. Be warned that the author may not have intended to support it.
getproperties int getproperties(): Undocumented in source. Be warned that the author may not have intended to support it.
hashCode int hashCode(): Undocumented in source. Be warned that the author may not have intended to support it.
identity Matrix4x3d identity(): Reset this matrix to the identity. <p> Please note that if a call to {@link #identity()} is immediately followed by a call to: {@link #translate(double, double, double) translate}, {@link #rotate(double, double, double, double) rotate}, {@link #scale(double, double, double) scale}, {@link #ortho(double, double, double, double, double, double) ortho}, {@link #ortho2D(double, double, double, double) ortho2D}, {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt}, {@link #lookAlong(double, double, double, double, double, double) lookAlong}, or any of their overloads, then the call to {@link #identity()} can be omitted and the subsequent call replaced with: {@link #translation(double, double, double) translation}, {@link #rotation(double, double, double, double) rotation}, {@link #scaling(double, double, double) scaling}, {@link #setOrtho(double, double, double, double, double, double) setOrtho}, {@link #setOrtho2D(double, double, double, double) setOrtho2D}, {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt}, {@link #setLookAlong(double, double, double, double, double, double) setLookAlong}, or any of their overloads.
invert Matrix4x3d invert(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
invert Matrix4x3d invert(): Invert this matrix.
invertOrtho Matrix4x3d invertOrtho(): Invert <code>this</code> orthographic projection matrix. <p> This method can be used to quickly obtain the inverse of an orthographic projection matrix.
invertOrtho Matrix4x3d invertOrtho(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
isFinite bool isFinite(): Undocumented in source. Be warned that the author may not have intended to support it.
lerp Matrix4x3d lerp(Matrix4x3d other, double t): Linearly interpolate <code>this</code> and <code>other</code> using the given interpolation factor <code>t</code> and store the result in <code>this</code>. <p> If <code>t</code> is <code>0.0</code> then the result is <code>this</code>. If the interpolation factor is <code>1.0</code> then the result is <code>other</code>.
lerp Matrix4x3d lerp(Matrix4x3d other, double t, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
lookAlong Matrix4x3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ): Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(double, double, double, double, double, double) setLookAlong()}
lookAlong Matrix4x3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest): Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(double, double, double, double, double, double) setLookAlong()}
lookAlong Matrix4x3d lookAlong(Vector3d dir, Vector3d up, Matrix4x3d dest): Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(Vector3d, Vector3d, Vector3d) lookAt} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(Vector3d, Vector3d) setLookAlong()}.
lookAlong Matrix4x3d lookAlong(Vector3d dir, Vector3d up): Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(Vector3d, Vector3d, Vector3d) lookAt} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(Vector3d, Vector3d) setLookAlong()}.
lookAt Matrix4x3d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ): Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()}.
lookAt Matrix4x3d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest): Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()}.
lookAt Matrix4x3d lookAt(Vector3d eye, Vector3d center, Vector3d up): Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(Vector3d, Vector3d, Vector3d)}.
lookAt Matrix4x3d lookAt(Vector3d eye, Vector3d center, Vector3d up, Matrix4x3d dest): Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(Vector3d, Vector3d, Vector3d)}.
lookAtLH Matrix4x3d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ): Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()}.
lookAtLH Matrix4x3d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest): Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()}.
lookAtLH Matrix4x3d lookAtLH(Vector3d eye, Vector3d center, Vector3d up): Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(Vector3d, Vector3d, Vector3d)}.
lookAtLH Matrix4x3d lookAtLH(Vector3d eye, Vector3d center, Vector3d up, Matrix4x3d dest): Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(Vector3d, Vector3d, Vector3d)}.
mapXZY Matrix4x3d mapXZY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 1 0 0 1 0 0 </pre>
mapXZY Matrix4x3d mapXZY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXZnY Matrix4x3d mapXZnY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 -1 0 0 1 0 0 </pre>
mapXZnY Matrix4x3d mapXZnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXnYnZ Matrix4x3d mapXnYnZ(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 -1 0 0 0 0 -1 0 </pre>
mapXnYnZ Matrix4x3d mapXnYnZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXnZY Matrix4x3d mapXnZY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 1 0 0 -1 0 0 </pre>
mapXnZY Matrix4x3d mapXnZY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXnZnY Matrix4x3d mapXnZnY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 -1 0 0 -1 0 0 </pre>
mapXnZnY Matrix4x3d mapXnZnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYXZ Matrix4x3d mapYXZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 1 0 0 0 0 0 1 0 </pre>
mapYXZ Matrix4x3d mapYXZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYXnZ Matrix4x3d mapYXnZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 1 0 0 0 0 0 -1 0 </pre>
mapYXnZ Matrix4x3d mapYXnZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYZX Matrix4x3d mapYZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 1 0 0 0 0 1 0 0 </pre>
mapYZX Matrix4x3d mapYZX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYZnX Matrix4x3d mapYZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 1 0 0 0 0 1 0 0 </pre>
mapYZnX Matrix4x3d mapYZnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnXZ Matrix4x3d mapYnXZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 1 0 0 0 0 0 1 0 </pre>
mapYnXZ Matrix4x3d mapYnXZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnXnZ Matrix4x3d mapYnXnZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 1 0 0 0 0 0 -1 0 </pre>
mapYnXnZ Matrix4x3d mapYnXnZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnZX Matrix4x3d mapYnZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 1 0 0 0 0 -1 0 0 </pre>
mapYnZX Matrix4x3d mapYnZX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnZnX Matrix4x3d mapYnZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 1 0 0 0 0 -1 0 0 </pre>
mapYnZnX Matrix4x3d mapYnZnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZXY Matrix4x3d mapZXY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 1 0 1 0 0 0 </pre>
mapZXY Matrix4x3d mapZXY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZXnY Matrix4x3d mapZXnY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 -1 0 1 0 0 0 </pre>
mapZXnY Matrix4x3d mapZXnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZYX Matrix4x3d mapZYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 1 0 0 1 0 0 0 </pre>
mapZYX Matrix4x3d mapZYX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZYnX Matrix4x3d mapZYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 1 0 0 1 0 0 0 </pre>
mapZYnX Matrix4x3d mapZYnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnXY Matrix4x3d mapZnXY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 1 0 1 0 0 0 </pre>
mapZnXY Matrix4x3d mapZnXY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnXnY Matrix4x3d mapZnXnY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 -1 0 1 0 0 0 </pre>
mapZnXnY Matrix4x3d mapZnXnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnYX Matrix4x3d mapZnYX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnYX Matrix4x3d mapZnYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 -1 0 0 1 0 0 0 </pre>
mapZnYnX Matrix4x3d mapZnYnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnYnX Matrix4x3d mapZnYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 -1 0 0 1 0 0 0 </pre>
mapnXYnZ Matrix4x3d mapnXYnZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXYnZ Matrix4x3d mapnXYnZ(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 1 0 0 0 0 -1 0 </pre>
mapnXZY Matrix4x3d mapnXZY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXZY Matrix4x3d mapnXZY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 1 0 0 1 0 0 </pre>
mapnXZnY Matrix4x3d mapnXZnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXZnY Matrix4x3d mapnXZnY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 -1 0 0 1 0 0 </pre>
mapnXnYZ Matrix4x3d mapnXnYZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnYZ Matrix4x3d mapnXnYZ(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 -1 0 0 0 0 1 0 </pre>
mapnXnYnZ Matrix4x3d mapnXnYnZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnYnZ Matrix4x3d mapnXnYnZ(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 -1 0 0 0 0 -1 0 </pre>
mapnXnZY Matrix4x3d mapnXnZY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnZY Matrix4x3d mapnXnZY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 1 0 0 -1 0 0 </pre>
mapnXnZnY Matrix4x3d mapnXnZnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnZnY Matrix4x3d mapnXnZnY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 -1 0 0 -1 0 0 </pre>
mapnYXZ Matrix4x3d mapnYXZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYXZ Matrix4x3d mapnYXZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 -1 0 0 0 0 0 1 0 </pre>
mapnYXnZ Matrix4x3d mapnYXnZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYXnZ Matrix4x3d mapnYXnZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 -1 0 0 0 0 0 -1 0 </pre>
mapnYZX Matrix4x3d mapnYZX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYZX Matrix4x3d mapnYZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 -1 0 0 0 0 1 0 0 </pre>
mapnYZnX Matrix4x3d mapnYZnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYZnX Matrix4x3d mapnYZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 -1 0 0 0 0 1 0 0 </pre>
mapnYnXZ Matrix4x3d mapnYnXZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnXZ Matrix4x3d mapnYnXZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 -1 0 0 0 0 0 1 0 </pre>
mapnYnXnZ Matrix4x3d mapnYnXnZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnXnZ Matrix4x3d mapnYnXnZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 -1 0 0 0 0 0 -1 0 </pre>
mapnYnZX Matrix4x3d mapnYnZX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnZX Matrix4x3d mapnYnZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 -1 0 0 0 0 -1 0 0 </pre>
mapnYnZnX Matrix4x3d mapnYnZnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnZnX Matrix4x3d mapnYnZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 -1 0 0 0 0 -1 0 0 </pre>
mapnZXY Matrix4x3d mapnZXY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZXY Matrix4x3d mapnZXY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 1 0 -1 0 0 0 </pre>
mapnZXnY Matrix4x3d mapnZXnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZXnY Matrix4x3d mapnZXnY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 -1 0 -1 0 0 0 </pre>
mapnZYX Matrix4x3d mapnZYX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZYX Matrix4x3d mapnZYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 1 0 0 -1 0 0 0 </pre>
mapnZYnX Matrix4x3d mapnZYnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZYnX Matrix4x3d mapnZYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 1 0 0 -1 0 0 0 </pre>
mapnZnXY Matrix4x3d mapnZnXY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnXY Matrix4x3d mapnZnXY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 1 0 -1 0 0 0 </pre>
mapnZnXnY Matrix4x3d mapnZnXnY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnXnY Matrix4x3d mapnZnXnY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 -1 0 -1 0 0 0 </pre>
mapnZnYX Matrix4x3d mapnZnYX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnYX Matrix4x3d mapnZnYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 -1 0 0 -1 0 0 0 </pre>
mapnZnYnX Matrix4x3d mapnZnYnX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnYnX Matrix4x3d mapnZnYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 -1 0 0 -1 0 0 0 </pre>
mul Matrix4x3d mul(Matrix4x3d right): Multiply this matrix by the supplied <code>right</code> matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the transformation of the right matrix will be applied first!
mul Matrix4x3d mul(Matrix4x3d right, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul3x3 Matrix4x3d mul3x3(double rm00, double rm01, double rm02, double rm10, double rm11, double rm12, double rm20, double rm21, double rm22): Multiply <code>this</code> by the 4x3 matrix with the column vectors <code>(rm00, rm01, rm02)</code>, <code>(rm10, rm11, rm12)</code>, <code>(rm20, rm21, rm22)</code> and <code>(0, 0, 0)</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the specified matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the transformation of the <code>R</code> matrix will be applied first!
mul3x3 Matrix4x3d mul3x3(double rm00, double rm01, double rm02, double rm10, double rm11, double rm12, double rm20, double rm21, double rm22, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulComponentWise Matrix4x3d mulComponentWise(Matrix4x3d other): Component-wise multiply <code>this</code> by <code>other</code>.
mulComponentWise Matrix4x3d mulComponentWise(Matrix4x3d other, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulOrtho Matrix4x3d mulOrtho(Matrix4x3d view): Multiply <code>this</code> orthographic projection matrix by the supplied <code>view</code> matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>V</code> the <code>view</code> matrix, then the new matrix will be <code>M * V</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * V * v</code>, the transformation of the <code>view</code> matrix will be applied first!
mulOrtho Matrix4x3d mulOrtho(Matrix4x3d view, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulTranslation Matrix4x3d mulTranslation(Matrix4x3d right, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
negateX Matrix4x3d negateX(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
negateX Matrix4x3d negateX(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 1 0 0 0 0 1 0 </pre>
negateY Matrix4x3d negateY(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
negateY Matrix4x3d negateY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 -1 0 0 0 0 1 0 </pre>
negateZ Matrix4x3d negateZ(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
negateZ Matrix4x3d negateZ(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 1 0 0 0 0 -1 0 </pre>
normal Matrix4x3d normal(): Compute a normal matrix from the left 3x3 submatrix of <code>this</code> and store it into the left 3x3 submatrix of <code>this</code>. All other values of <code>this</code> will be set to {@link #identity() identity}. <p> The normal matrix of <code>m</code> is the transpose of the inverse of <code>m</code>. <p> Please note that, if <code>this</code> is an orthogonal matrix or a matrix whose columns are orthogonal vectors, then this method <i>need not</i> be invoked, since in that case <code>this</code> itself is its normal matrix. In that case, use {@link #set3x3(Matrix4x3d)} to set a given Matrix4x3d to only the left 3x3 submatrix of this matrix.
normal Matrix4x3d normal(Matrix4x3d dest): Compute a normal matrix from the left 3x3 submatrix of <code>this</code> and store it into the left 3x3 submatrix of <code>dest</code>. All other values of <code>dest</code> will be set to {@link #identity() identity}. <p> The normal matrix of <code>m</code> is the transpose of the inverse of <code>m</code>. <p> Please note that, if <code>this</code> is an orthogonal matrix or a matrix whose columns are orthogonal vectors, then this method <i>need not</i> be invoked, since in that case <code>this</code> itself is its normal matrix. In that case, use {@link #set3x3(Matrix4x3d)} to set a given Matrix4x3d to only the left 3x3 submatrix of a given matrix.
normal Matrix3d normal(Matrix3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
normalize3x3 Matrix4x3d normalize3x3(): Normalize the left 3x3 submatrix of this matrix. <p> The resulting matrix will map unit vectors to unit vectors, though a pair of orthogonal input unit vectors need not be mapped to a pair of orthogonal output vectors if the original matrix was not orthogonal itself (i.e. had <i>skewing</i>).
normalize3x3 Matrix4x3d normalize3x3(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
normalize3x3 Matrix3d normalize3x3(Matrix3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
normalizedPositiveX Vector3d normalizedPositiveX(Vector3d dir): Undocumented in source. Be warned that the author may not have intended to support it.
normalizedPositiveY Vector3d normalizedPositiveY(Vector3d dir): Undocumented in source. Be warned that the author may not have intended to support it.
normalizedPositiveZ Vector3d normalizedPositiveZ(Vector3d dir): Undocumented in source. Be warned that the author may not have intended to support it.
obliqueZ Matrix4x3d obliqueZ(double a, double b, Matrix4x3d dest): Apply an oblique projection transformation to this matrix with the given values for <code>a</code> and <code>b</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the oblique transformation matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the oblique transformation will be applied first! <p> The oblique transformation is defined as: <pre> x' = x + a*z y' = y + a*z z' = z </pre> or in matrix form: <pre> 1 0 a 0 0 1 b 0 0 0 1 0 </pre>
obliqueZ Matrix4x3d obliqueZ(double a, double b): Apply an oblique projection transformation to this matrix with the given values for <code>a</code> and <code>b</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the oblique transformation matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the oblique transformation will be applied first! <p> The oblique transformation is defined as: <pre> x' = x + a*z y' = y + a*z z' = z </pre> or in matrix form: <pre> 1 0 a 0 0 1 b 0 0 0 1 0 </pre>
origin Vector3d origin(Vector3d origin): Undocumented in source. Be warned that the author may not have intended to support it.
ortho Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest): Apply an orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
ortho Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest): Apply an orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
ortho Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Apply an orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
ortho Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar): Apply an orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
ortho2D Matrix4x3d ortho2D(double left, double right, double bottom, double top, Matrix4x3d dest): Apply an orthographic projection transformation for a right-handed coordinate system to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4x3d) ortho()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2D(double, double, double, double) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
ortho2D Matrix4x3d ortho2D(double left, double right, double bottom, double top): Apply an orthographic projection transformation for a right-handed coordinate system to this matrix. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double) ortho()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2D(double, double, double, double) setOrtho2D()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
ortho2DLH Matrix4x3d ortho2DLH(double left, double right, double bottom, double top, Matrix4x3d dest): Apply an orthographic projection transformation for a left-handed coordinate system to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4x3d) orthoLH()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2DLH(double, double, double, double) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
ortho2DLH Matrix4x3d ortho2DLH(double left, double right, double bottom, double top): Apply an orthographic projection transformation for a left-handed coordinate system to this matrix. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double) orthoLH()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2DLH(double, double, double, double) setOrtho2DLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoLH Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest): Apply an orthographic projection transformation for a left-handed coordiante system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double, bool) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoLH Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest): Apply an orthographic projection transformation for a left-handed coordiante system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoLH Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Apply an orthographic projection transformation for a left-handed coordiante system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double, bool) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoLH Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar): Apply an orthographic projection transformation for a left-handed coordiante system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetric Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest): Apply a symmetric orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, bool, Matrix4x3d) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double, bool) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetric Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, Matrix4x3d dest): Apply a symmetric orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4x3d) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetric Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne): Apply a symmetric orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, bool) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double, bool) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetric Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar): Apply a symmetric orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetricLH Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest): Apply a symmetric orthographic projection transformation for a left-handed coordinate system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, bool, Matrix4x3d) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double, bool) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetricLH Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, Matrix4x3d dest): Apply a symmetric orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4x3d) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetricLH Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne): Apply a symmetric orthographic projection transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, bool) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double, bool) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
orthoSymmetricLH Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar): Apply a symmetric orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
pick Matrix4x3d pick(double x, double y, double width, double height, int[] viewport, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
pick Matrix4x3d pick(double x, double y, double width, double height, int[] viewport): Apply a picking transformation to this matrix using the given window coordinates <code>(x, y)</code> as the pick center and the given <code>(width, height)</code> as the size of the picking region in window coordinates.
positiveX Vector3d positiveX(Vector3d dir): Undocumented in source. Be warned that the author may not have intended to support it.
positiveY Vector3d positiveY(Vector3d dir): Undocumented in source. Be warned that the author may not have intended to support it.
positiveZ Vector3d positiveZ(Vector3d dir): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4x3d reflect(double a, double b, double c, double d, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4x3d reflect(double a, double b, double c, double d): Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the equation <code>x*a + y*b + z*c + d = 0</code>. <p> The vector <code>(a, b, c)</code> must be a unit vector. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first! <p> Reference: <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb281733(v=vs.85).aspx">msdn.microsoft.com</a>
reflect Matrix4x3d reflect(double nx, double ny, double nz, double px, double py, double pz): Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first!
reflect Matrix4x3d reflect(double nx, double ny, double nz, double px, double py, double pz, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4x3d reflect(Vector3d normal, Vector3d point): Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first!
reflect Matrix4x3d reflect(Quaterniond orientation, Vector3d point): Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation and a point on the plane. <p> This method can be used to build a reflection transformation based on the orientation of a mirror object in the scene. It is assumed that the default mirror plane's normal is <code>(0, 0, 1)</code>. So, if the given {@link Quaterniond} is the identity (does not apply any additional rotation), the reflection plane will be <code>z=0</code>, offset by the given <code>point</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first!
reflect Matrix4x3d reflect(Quaterniond orientation, Vector3d point, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4x3d reflect(Vector3d normal, Vector3d point, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflection Matrix4x3d reflection(double a, double b, double c, double d): Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the equation <code>x*a + y*b + z*c + d = 0</code>. <p> The vector <code>(a, b, c)</code> must be a unit vector. <p> Reference: <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb281733(v=vs.85).aspx">msdn.microsoft.com</a>
reflection Matrix4x3d reflection(double nx, double ny, double nz, double px, double py, double pz): Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the plane normal and a point on the plane.
reflection Matrix4x3d reflection(Vector3d normal, Vector3d point): Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the plane normal and a point on the plane.
reflection Matrix4x3d reflection(Quaterniond orientation, Vector3d point): Set this matrix to a mirror/reflection transformation that reflects about a plane specified via the plane orientation and a point on the plane. <p> This method can be used to build a reflection transformation based on the orientation of a mirror object in the scene. It is assumed that the default mirror plane's normal is <code>(0, 0, 1)</code>. So, if the given {@link Quaterniond} is the identity (does not apply any additional rotation), the reflection plane will be <code>z=0</code>, offset by the given <code>point</code>.
rotate Matrix4x3d rotate(Quaterniond quat, Matrix4x3d dest): Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotate Matrix4x3d rotate(Quaterniond quat): Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotate Matrix4x3d rotate(AxisAngle4d axisAngle): Apply a rotation transformation, rotating about the given {@link AxisAngle4d}, to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given {@link AxisAngle4d}, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the {@link AxisAngle4d} rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotate Matrix4x3d rotate(AxisAngle4d axisAngle, Matrix4x3d dest): Apply a rotation transformation, rotating about the given {@link AxisAngle4d} and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given {@link AxisAngle4d}, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the {@link AxisAngle4d} rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotate Matrix4x3d rotate(double angle, Vector3d axis): Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given angle and axis, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the axis-angle rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(double, Vector3d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotate Matrix4x3d rotate(double angle, Vector3d axis, Matrix4x3d dest): Apply a rotation transformation, rotating the given radians about the specified axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given angle and axis, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the axis-angle rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(double, Vector3d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotate Matrix4x3d rotate(double ang, double x, double y, double z): Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code> , the rotation will be applied first! <p> In order to set the matrix to a rotation matrix without post-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}.
rotate Matrix4x3d rotate(double ang, double x, double y, double z, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateAround Matrix4x3d rotateAround(Quaterniond quat, double ox, double oy, double oz, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateAround Matrix4x3d rotateAround(Quaterniond quat, double ox, double oy, double oz): Apply the rotation transformation of the given {@link Quaterniond} to this matrix while using <code>(ox, oy, oz)</code> as the rotation origin. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> This method is equivalent to calling: <code>translate(ox, oy, oz).rotate(quat).translate(-ox, -oy, -oz)</code> <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateLocal Matrix4x3d rotateLocal(Quaterniond quat, Matrix4x3d dest): Pre-multiply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>Q * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>Q * M * v</code>, the quaternion rotation will be applied last! <p> In order to set the matrix to a rotation transformation without pre-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateLocal Matrix4x3d rotateLocal(Quaterniond quat): Pre-multiply the rotation transformation of the given {@link Quaterniond} to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>Q * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>Q * M * v</code>, the quaternion rotation will be applied last! <p> In order to set the matrix to a rotation transformation without pre-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateLocal Matrix4x3d rotateLocal(double ang, double x, double y, double z): Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis. <p> The axis described by the three components needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateLocal Matrix4x3d rotateLocal(double ang, double x, double y, double z, Matrix4x3d dest): Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis and store the result in <code>dest</code>. <p> The axis described by the three components needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateLocalX Matrix4x3d rotateLocalX(double ang): Pre-multiply a rotation to this matrix by rotating the given amount of radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationX(double) rotationX()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateLocalX Matrix4x3d rotateLocalX(double ang, Matrix4x3d dest): Pre-multiply a rotation around the X axis to this matrix by rotating the given amount of radians about the X axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationX(double) rotationX()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateLocalY Matrix4x3d rotateLocalY(double ang): Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Y axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationY(double) rotationY()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateLocalY Matrix4x3d rotateLocalY(double ang, Matrix4x3d dest): Pre-multiply a rotation around the Y axis to this matrix by rotating the given amount of radians about the Y axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationY(double) rotationY()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateLocalZ Matrix4x3d rotateLocalZ(double ang): Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationZ(double) rotationY()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateLocalZ Matrix4x3d rotateLocalZ(double ang, Matrix4x3d dest): Pre-multiply a rotation around the Z axis to this matrix by rotating the given amount of radians about the Z axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationZ(double) rotationZ()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateTowards Matrix4x3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest): Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>(dirX, dirY, dirZ)</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(double, double, double, double, double, double) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invert(), dest)</code>
rotateTowards Matrix4x3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ): Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>(dirX, dirY, dirZ)</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(double, double, double, double, double, double) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invert())</code>
rotateTowards Matrix4x3d rotateTowards(Vector3d dir, Vector3d up): Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>dir</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invert())</code>
rotateTowards Matrix4x3d rotateTowards(Vector3d dir, Vector3d up, Matrix4x3d dest): Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>dir</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invert(), dest)</code>
rotateTranslation Matrix4x3d rotateTranslation(Quaterniond quat, Matrix4x3d dest): Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix, which is assumed to only contain a translation, and store the result in <code>dest</code>. <p> This method assumes <code>this</code> to only contain a translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateTranslation Matrix4x3d rotateTranslation(double ang, double x, double y, double z, Matrix4x3d dest): Apply rotation to this matrix, which is assumed to only contain a translation, by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis and store the result in <code>dest</code>. <p> This method assumes <code>this</code> to only contain a translation. <p> The axis described by the three components needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> In order to set the matrix to a rotation matrix without post-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
rotateX Matrix4x3d rotateX(double ang): Apply rotation about the X axis to this matrix by rotating the given amount of radians. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
rotateX Matrix4x3d rotateX(double ang, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ Matrix4x3d rotateXYZ(double angleX, double angleY, double angleZ, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ Matrix4x3d rotateXYZ(double angleX, double angleY, double angleZ): Apply rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateX(angleX).rotateY(angleY).rotateZ(angleZ)</code>
rotateXYZ Matrix4x3d rotateXYZ(Vector3d angles): Apply rotation of <code>angles.x</code> radians about the X axis, followed by a rotation of <code>angles.y</code> radians about the Y axis and followed by a rotation of <code>angles.z</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateX(angles.x).rotateY(angles.y).rotateZ(angles.z)</code>
rotateY Matrix4x3d rotateY(double ang): Apply rotation about the Y axis to this matrix by rotating the given amount of radians. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
rotateY Matrix4x3d rotateY(double ang, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateYXZ Matrix4x3d rotateYXZ(Vector3d angles): Apply rotation of <code>angles.y</code> radians about the Y axis, followed by a rotation of <code>angles.x</code> radians about the X axis and followed by a rotation of <code>angles.z</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateY(angles.y).rotateX(angles.x).rotateZ(angles.z)</code>
rotateYXZ Matrix4x3d rotateYXZ(double angleY, double angleX, double angleZ): Apply rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateY(angleY).rotateX(angleX).rotateZ(angleZ)</code>
rotateYXZ Matrix4x3d rotateYXZ(double angleY, double angleX, double angleZ, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateZ Matrix4x3d rotateZ(double ang): Apply rotation about the Z axis to this matrix by rotating the given amount of radians. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
rotateZ Matrix4x3d rotateZ(double ang, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateZYX Matrix4x3d rotateZYX(double angleZ, double angleY, double angleX): Apply rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleX</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateZ(angleZ).rotateY(angleY).rotateX(angleX)</code>
rotateZYX Matrix4x3d rotateZYX(Vector3d angles): Apply rotation of <code>angles.z</code> radians about the Z axis, followed by a rotation of <code>angles.y</code> radians about the Y axis and followed by a rotation of <code>angles.x</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateZ(angles.z).rotateY(angles.y).rotateX(angles.x)</code>
rotateZYX Matrix4x3d rotateZYX(double angleZ, double angleY, double angleX, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotation Matrix4x3d rotation(AxisAngle4d angleAxis): Set this matrix to a rotation transformation using the given {@link AxisAngle4d}. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation. <p> In order to apply the rotation transformation to an existing transformation, use {@link #rotate(AxisAngle4d) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotation Matrix4x3d rotation(Quaterniond quat): Set this matrix to the rotation - and possibly scaling - transformation of the given {@link Quaterniond}. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation. <p> In order to apply the rotation transformation to an existing transformation, use {@link #rotate(Quaterniond) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotation Matrix4x3d rotation(double angle, Vector3d axis): Set this matrix to a rotation matrix which rotates the given radians about a given axis. <p> The axis described by the <code>axis</code> vector needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
rotation Matrix4x3d rotation(double angle, double x, double y, double z): Set this matrix to a rotation matrix which rotates the given radians about a given axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> From <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">Wikipedia</a>
rotationAround Matrix4x3d rotationAround(Quaterniond quat, double ox, double oy, double oz): Set this matrix to a transformation composed of a rotation of the specified {@link Quaterniond} while using <code>(ox, oy, oz)</code> as the rotation origin. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(ox, oy, oz).rotate(quat).translate(-ox, -oy, -oz)</code> <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotationTowards Matrix4x3d rotationTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ): Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local <code>-z</code> axis with <code>(dirX, dirY, dirZ)</code>. <p> In order to apply the rotation transformation to a previous existing transformation, use {@link #rotateTowards(double, double, double, double, double, double) rotateTowards}. <p> This method is equivalent to calling: <code>setLookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invert()</code>
rotationTowards Matrix4x3d rotationTowards(Vector3d dir, Vector3d up): Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local <code>-z</code> axis with <code>dir</code>. <p> In order to apply the rotation transformation to a previous existing transformation, use {@link #rotateTowards(double, double, double, double, double, double) rotateTowards}. <p> This method is equivalent to calling: <code>setLookAt(new Vector3d(), new Vector3d(dir).negate(), up).invert()</code>
rotationX Matrix4x3d rotationX(double ang): Set this matrix to a rotation transformation about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
rotationXYZ Matrix4x3d rotationXYZ(double angleX, double angleY, double angleZ): Set this matrix to a rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>rotationX(angleX).rotateY(angleY).rotateZ(angleZ)</code>
rotationY Matrix4x3d rotationY(double ang): Set this matrix to a rotation transformation about the Y axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
rotationYXZ Matrix4x3d rotationYXZ(double angleY, double angleX, double angleZ): Set this matrix to a rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>rotationY(angleY).rotateX(angleX).rotateZ(angleZ)</code>
rotationZ Matrix4x3d rotationZ(double ang): Set this matrix to a rotation transformation about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
rotationZYX Matrix4x3d rotationZYX(double angleZ, double angleY, double angleX): Set this matrix to a rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleX</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>rotationZ(angleZ).rotateY(angleY).rotateX(angleX)</code>
scale Matrix4x3d scale(double xyz): Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code> , the scaling will be applied first!
scale Matrix4x3d scale(double xyz, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scale Matrix4x3d scale(double x, double y, double z): Apply scaling to <code>this</code> matrix by scaling the base axes by the given x, y and z factors. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code> , the scaling will be applied first!
scale Matrix4x3d scale(double x, double y, double z, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scale Matrix4x3d scale(Vector3d xyz): Apply scaling to this matrix by scaling the base axes by the given <code>xyz.x</code>, <code>xyz.y</code> and <code>xyz.z</code> factors, respectively. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first!
scale Matrix4x3d scale(Vector3d xyz, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleAround Matrix4x3d scaleAround(double factor, double ox, double oy, double oz, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleAround Matrix4x3d scaleAround(double factor, double ox, double oy, double oz): Apply scaling to this matrix by scaling all three base axes by the given <code>factor</code> while using <code>(ox, oy, oz)</code> as the scaling origin. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first! <p> This method is equivalent to calling: <code>translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz)</code>
scaleAround Matrix4x3d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz): Apply scaling to this matrix by scaling the base axes by the given sx, sy and sz factors while using <code>(ox, oy, oz)</code> as the scaling origin. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first! <p> This method is equivalent to calling: <code>translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz)</code>
scaleAround Matrix4x3d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal Matrix4x3d scaleLocal(double x, double y, double z): Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>S * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>S * M * v</code>, the scaling will be applied last!
scaleLocal Matrix4x3d scaleLocal(double x, double y, double z, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleXY Matrix4x3d scaleXY(double x, double y): Apply scaling to this matrix by scaling the X axis by <code>x</code> and the Y axis by <code>y</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first!
scaleXY Matrix4x3d scaleXY(double x, double y, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaling Matrix4x3d scaling(Vector3d xyz): Set this matrix to be a simple scale matrix which scales the base axes by <code>xyz.x</code>, <code>xyz.y</code> and <code>xyz.z</code>, respectively. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling. <p> In order to post-multiply a scaling transformation directly to a matrix use {@link #scale(Vector3d) scale()} instead.
scaling Matrix4x3d scaling(double x, double y, double z): Set this matrix to be a simple scale matrix.
scaling Matrix4x3d scaling(double factor): Set this matrix to be a simple scale matrix, which scales all axes uniformly by the given factor. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling. <p> In order to post-multiply a scaling transformation directly to a matrix, use {@link #scale(double) scale()} instead.
set Matrix4x3d set(AxisAngle4d axisAngle): Set this matrix to be equivalent to the rotation specified by the given {@link AxisAngle4d}.
set Matrix4x3d set(Matrix4x3d m): Store the values of the given matrix <code>m</code> into <code>this</code> matrix.
set Matrix4x3d set(float[] m): Set the values in the matrix using a float array that contains the matrix elements in column-major order. <p> The results will look like this:<br><br>
set Matrix4x3d set(float[] m, int off): Set the values in the matrix using a float array that contains the matrix elements in column-major order. <p> The results will look like this:<br><br>
set Matrix4x3d set(double[] m): Set the values in the matrix using a double array that contains the matrix elements in column-major order. <p> The results will look like this:<br><br>
set Matrix4x3d set(double[] m, int off): Set the values in the matrix using a double array that contains the matrix elements in column-major order. <p> The results will look like this:<br><br>
set Matrix4x3d set(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32): Set the values within this matrix to the supplied double values. The matrix will look like this:<br><br>
set Matrix4x3d set(Matrix4d m): Store the values of the upper 4x3 submatrix of <code>m</code> into <code>this</code> matrix.
set Matrix4x3d set(Matrix3d mat): Set the left 3x3 submatrix of this {@link Matrix4x3d} to the given {@link Matrix3d} and the rest to identity.
set Matrix4x3d set(Vector3d col0, Vector3d col1, Vector3d col2, Vector3d col3): Set the four columns of this matrix to the supplied vectors, respectively.
set Matrix4x3d set(Quaterniond q): Set this matrix to be equivalent to the rotation - and possibly scaling - specified by the given {@link Quaterniond}. <p> This method is equivalent to calling: <code>rotation(q)</code>
set3x3 Matrix4x3d set3x3(Matrix3d mat): Set the left 3x3 submatrix of this {@link Matrix4x3d} to the given {@link Matrix3d} and don't change the other elements.
set3x3 Matrix4x3d set3x3(Matrix4x3d mat): Set the left 3x3 submatrix of this {@link Matrix4x3d} to that of the given {@link Matrix4x3d} and don't change the other elements.
setColumn Matrix4x3d setColumn(int column, Vector3d src): Set the column at the given <code>column</code> index, starting with <code>0</code>.
setLookAlong Matrix4x3d setLookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ): Set this matrix to a rotation transformation to make <code>-z</code> point along <code>dir</code>. <p> This is equivalent to calling {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to apply the lookalong transformation to any previous existing transformation, use {@link #lookAlong(double, double, double, double, double, double) lookAlong()}
setLookAlong Matrix4x3d setLookAlong(Vector3d dir, Vector3d up): Set this matrix to a rotation transformation to make <code>-z</code> point along <code>dir</code>. <p> This is equivalent to calling {@link #setLookAt(Vector3d, Vector3d, Vector3d) setLookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to apply the lookalong transformation to any previous existing transformation, use {@link #lookAlong(Vector3d, Vector3d)}.
setLookAt Matrix4x3d setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ): Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt}.
setLookAt Matrix4x3d setLookAt(Vector3d eye, Vector3d center, Vector3d up): Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> In order to not make use of vectors to specify <code>eye</code>, <code>center</code> and <code>up</code> but use primitives, like in the GLU function, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()} instead. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAt(Vector3d, Vector3d, Vector3d) lookAt()}.
setLookAtLH Matrix4x3d setLookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ): Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAtLH(double, double, double, double, double, double, double, double, double) lookAtLH}.
setLookAtLH Matrix4x3d setLookAtLH(Vector3d eye, Vector3d center, Vector3d up): Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> In order to not make use of vectors to specify <code>eye</code>, <code>center</code> and <code>up</code> but use primitives, like in the GLU function, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()} instead. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAtLH(Vector3d, Vector3d, Vector3d) lookAt()}.
setOrtho Matrix4x3d setOrtho(double left, double right, double bottom, double top, double zNear, double zFar): Set this matrix to be an orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho(double, double, double, double, double, double) ortho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrtho Matrix4x3d setOrtho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Set this matrix to be an orthographic projection transformation for a right-handed coordinate system using the given NDC z range. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho(double, double, double, double, double, double, bool) ortho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrtho2D Matrix4x3d setOrtho2D(double left, double right, double bottom, double top): Set this matrix to be an orthographic projection transformation for a right-handed coordinate system. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double) setOrtho()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho2D(double, double, double, double) ortho2D()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrtho2DLH Matrix4x3d setOrtho2DLH(double left, double right, double bottom, double top): Set this matrix to be an orthographic projection transformation for a left-handed coordinate system. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double) setOrthoLH()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho2DLH(double, double, double, double) ortho2DLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrthoLH Matrix4x3d setOrthoLH(double left, double right, double bottom, double top, double zNear, double zFar): Set this matrix to be an orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #orthoLH(double, double, double, double, double, double) orthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrthoLH Matrix4x3d setOrthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Set this matrix to be an orthographic projection transformation for a left-handed coordinate system using the given NDC z range. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #orthoLH(double, double, double, double, double, double, bool) orthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrthoSymmetric Matrix4x3d setOrthoSymmetric(double width, double height, double zNear, double zFar): Set this matrix to be a symmetric orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double) setOrtho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetric(double, double, double, double) orthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrthoSymmetric Matrix4x3d setOrthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne): Set this matrix to be a symmetric orthographic projection transformation for a right-handed coordinate system using the given NDC z range. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetric(double, double, double, double, bool) orthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrthoSymmetricLH Matrix4x3d setOrthoSymmetricLH(double width, double height, double zNear, double zFar): Set this matrix to be a symmetric orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> This method is equivalent to calling {@link #setOrthoLH(double, double, double, double, double, double) setOrthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetricLH(double, double, double, double) orthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setOrthoSymmetricLH Matrix4x3d setOrthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne): Set this matrix to be a symmetric orthographic projection transformation for a left-handed coordinate system using the given NDC z range. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetricLH(double, double, double, double, bool) orthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
setRotationXYZ Matrix4x3d setRotationXYZ(double angleX, double angleY, double angleZ): Set only the left 3x3 submatrix of this matrix to a rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
setRotationYXZ Matrix4x3d setRotationYXZ(double angleY, double angleX, double angleZ): Set only the left 3x3 submatrix of this matrix to a rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
setRotationZYX Matrix4x3d setRotationZYX(double angleZ, double angleY, double angleX): Set only the left 3x3 submatrix of this matrix to a rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleX</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
setRow Matrix4x3d setRow(int row, Vector4d src): Set the row at the given <code>row</code> index, starting with <code>0</code>.
setTranslation Matrix4x3d setTranslation(Vector3d xyz): Set only the translation components <code>(m30, m31, m32)</code> of this matrix to the given values <code>(xyz.x, xyz.y, xyz.z)</code>. <p> To build a translation matrix instead, use {@link #translation(Vector3d)}. To apply a translation, use {@link #translate(Vector3d)}.
setTranslation Matrix4x3d setTranslation(double x, double y, double z): Set only the translation components <code>(m30, m31, m32)</code> of this matrix to the given values <code>(x, y, z)</code>. <p> To build a translation matrix instead, use {@link #translation(double, double, double)}. To apply a translation, use {@link #translate(double, double, double)}.
setm00 Matrix4x3d setm00(double m00): Set the value of the matrix element at column 0 and row 0.
setm01 Matrix4x3d setm01(double m01): Set the value of the matrix element at column 0 and row 1.
setm02 Matrix4x3d setm02(double m02): Set the value of the matrix element at column 0 and row 2.
setm10 Matrix4x3d setm10(double m10): Set the value of the matrix element at column 1 and row 0.
setm11 Matrix4x3d setm11(double m11): Set the value of the matrix element at column 1 and row 1.
setm12 Matrix4x3d setm12(double m12): Set the value of the matrix element at column 1 and row 2.
setm20 Matrix4x3d setm20(double m20): Set the value of the matrix element at column 2 and row 0.
setm21 Matrix4x3d setm21(double m21): Set the value of the matrix element at column 2 and row 1.
setm22 Matrix4x3d setm22(double m22): Set the value of the matrix element at column 2 and row 2.
setm30 Matrix4x3d setm30(double m30): Set the value of the matrix element at column 3 and row 0.
setm31 Matrix4x3d setm31(double m31): Set the value of the matrix element at column 3 and row 1.
setm32 Matrix4x3d setm32(double m32): Set the value of the matrix element at column 3 and row 2.
shadow Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4x3d planeTransform): Apply a projection transformation to this matrix that projects onto the plane with the general plane equation <code>y = 0</code> as if casting a shadow from a given light position/direction <code>(lightX, lightY, lightZ, lightW)</code>. <p> Before the shadow projection is applied, the plane is transformed via the specified <code>planeTransformation</code>. <p> If <code>lightW</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first!
shadow Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4x3d planeTransform, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4x3d shadow(Vector4d light, Matrix4x3d planeTransform): Apply a projection transformation to this matrix that projects onto the plane with the general plane equation <code>y = 0</code> as if casting a shadow from a given light position/direction <code>light</code>. <p> Before the shadow projection is applied, the plane is transformed via the specified <code>planeTransformation</code>. <p> If <code>light.w</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first!
shadow Matrix4x3d shadow(Vector4d light, Matrix4x3d planeTransform, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d): Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation <code>x*a + y*b + z*c + d = 0</code> as if casting a shadow from a given light position/direction <code>(lightX, lightY, lightZ, lightW)</code>. <p> If <code>lightW</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first! <p> Reference: <a href="ftp://ftp.sgi.com/opengl/contrib/blythe/advanced99/notes/node192.html">ftp.sgi.com</a>
shadow Matrix4x3d shadow(Vector4d light, double a, double b, double c, double d, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4x3d shadow(Vector4d light, double a, double b, double c, double d): Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation <code>x*a + y*b + z*c + d = 0</code> as if casting a shadow from a given light position/direction <code>light</code>. <p> If <code>light.w</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first! <p> Reference: <a href="ftp://ftp.sgi.com/opengl/contrib/blythe/advanced99/notes/node192.html">ftp.sgi.com</a>
sub Matrix4x3d sub(Matrix4x3d subtrahend, Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
sub Matrix4x3d sub(Matrix4x3d subtrahend): Component-wise subtract <code>subtrahend</code> from <code>this</code>.
swap Matrix4x3d swap(Matrix4x3d other): Exchange the values of <code>this</code> matrix with the given <code>other</code> matrix.
transform Vector4d transform(Vector4d v, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transform Vector4d transform(Vector4d v): Undocumented in source. Be warned that the author may not have intended to support it.
transformAab Matrix4x3d transformAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector3d outMin, Vector3d outMax): Undocumented in source. Be warned that the author may not have intended to support it.
transformAab Matrix4x3d transformAab(Vector3d min, Vector3d max, Vector3d outMin, Vector3d outMax): Undocumented in source. Be warned that the author may not have intended to support it.
transformDirection Vector3d transformDirection(Vector3d v, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformDirection Vector3d transformDirection(Vector3d v): Undocumented in source. Be warned that the author may not have intended to support it.
transformPosition Vector3d transformPosition(Vector3d v, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformPosition Vector3d transformPosition(Vector3d v): Undocumented in source. Be warned that the author may not have intended to support it.
translate Matrix4x3d translate(double x, double y, double z): Apply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(double, double, double)}.
translate Matrix4x3d translate(double x, double y, double z, Matrix4x3d dest): Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(double, double, double)}.
translate Matrix4x3d translate(Vector3d offset, Matrix4x3d dest): Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(Vector3d)}.
translate Matrix4x3d translate(Vector3d offset): Apply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(Vector3d)}.
translateLocal Matrix4x3d translateLocal(double x, double y, double z): Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(double, double, double)}.
translateLocal Matrix4x3d translateLocal(double x, double y, double z, Matrix4x3d dest): Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(double, double, double)}.
translateLocal Matrix4x3d translateLocal(Vector3d offset, Matrix4x3d dest): Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(Vector3d)}.
translateLocal Matrix4x3d translateLocal(Vector3d offset): Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(Vector3d)}.
translation Matrix4x3d translation(Vector3d offset): Set this matrix to be a simple translation matrix. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional translation.
translation Matrix4x3d translation(double x, double y, double z): Set this matrix to be a simple translation matrix. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional translation.
translationRotate Matrix4x3d translationRotate(Vector3d translation, Quaterniond quat): Set <code>this</code> matrix to <code>T * R</code>, where <code>T</code> is the given <code>translation</code> and <code>R</code> is a rotation transformation specified by the given quaternion. <p> When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(translation).rotate(quat)</code>
translationRotate Matrix4x3d translationRotate(double tx, double ty, double tz, double qx, double qy, double qz, double qw): Set <code>this</code> matrix to <code>T * R</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code> and <code>R</code> is a rotation - and possibly scaling - transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>. <p> When transforming a vector by the resulting matrix the rotation - and possibly scaling - transformation will be applied first and then the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat)</code>
translationRotate Matrix4x3d translationRotate(double tx, double ty, double tz, Quaterniond quat): Set <code>this</code> matrix to <code>T * R</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code> and <code>R</code> is a rotation transformation specified by the given quaternion. <p> When transforming a vector by the resulting matrix the rotation transformation will be applied first and then the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat)</code>
translationRotateInvert Matrix4x3d translationRotateInvert(Vector3d translation, Quaterniond quat): Set <code>this</code> matrix to <code>(T * R)<sup>-1</sup></code>, where <code>T</code> is the given <code>translation</code> and <code>R</code> is a rotation transformation specified by the given quaternion. <p> This method is equivalent to calling: <code>translationRotate(...).invert()</code>
translationRotateInvert Matrix4x3d translationRotateInvert(double tx, double ty, double tz, double qx, double qy, double qz, double qw): Set <code>this</code> matrix to <code>(T * R)<sup>-1</sup></code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code> and <code>R</code> is a rotation transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>. <p> This method is equivalent to calling: <code>translationRotate(...).invert()</code>
translationRotateMul Matrix4x3d translationRotateMul(double tx, double ty, double tz, double qx, double qy, double qz, double qw, Matrix4x3d mat): Set <code>this</code> matrix to <code>T * R * M</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code>, <code>R</code> is a rotation - and possibly scaling - transformation specified by the quaternion <code>(qx, qy, qz, qw)</code> and <code>M</code> is the given matrix <code>mat</code> <p> When transforming a vector by the resulting matrix the transformation described by <code>M</code> will be applied first, then the scaling, then rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat).mul(mat)</code>
translationRotateScale Matrix4x3d translationRotateScale(Vector3d translation, Quaterniond quat, Vector3d scale): Set <code>this</code> matrix to <code>T * R * S</code>, where <code>T</code> is the given <code>translation</code>, <code>R</code> is a rotation transformation specified by the given quaternion, and <code>S</code> is a scaling transformation which scales the axes by <code>scale</code>. <p> When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(translation).rotate(quat).scale(scale)</code>
translationRotateScale Matrix4x3d translationRotateScale(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz): Set <code>this</code> matrix to <code>T * R * S</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code>, <code>R</code> is a rotation transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>, and <code>S</code> is a scaling transformation which scales the three axes x, y and z by <code>(sx, sy, sz)</code>. <p> When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat).scale(sx, sy, sz)</code>
translationRotateScaleMul Matrix4x3d translationRotateScaleMul(Vector3d translation, Quaterniond quat, Vector3d scale, Matrix4x3d m): Set <code>this</code> matrix to <code>T * R * S * M</code>, where <code>T</code> is the given <code>translation</code>, <code>R</code> is a rotation transformation specified by the given quaternion, <code>S</code> is a scaling transformation which scales the axes by <code>scale</code>. <p> When transforming a vector by the resulting matrix the transformation described by <code>M</code> will be applied first, then the scaling, then rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(translation).rotate(quat).scale(scale).mul(m)</code>
translationRotateScaleMul Matrix4x3d translationRotateScaleMul(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz, Matrix4x3d m): Set <code>this</code> matrix to <code>T * R * S * M</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code>, <code>R</code> is a rotation transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>, <code>S</code> is a scaling transformation which scales the three axes x, y and z by <code>(sx, sy, sz)</code>. <p> When transforming a vector by the resulting matrix the transformation described by <code>M</code> will be applied first, then the scaling, then rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat).scale(sx, sy, sz).mul(m)</code>
translationRotateTowards Matrix4x3d translationRotateTowards(Vector3d pos, Vector3d dir, Vector3d up): Set this matrix to a model transformation for a right-handed coordinate system, that translates to the given <code>pos</code> and aligns the local <code>-z</code> axis with <code>dir</code>. <p> This method is equivalent to calling: <code>translation(pos).rotateTowards(dir, up)</code>
translationRotateTowards Matrix4x3d translationRotateTowards(double posX, double posY, double posZ, double dirX, double dirY, double dirZ, double upX, double upY, double upZ): Set this matrix to a model transformation for a right-handed coordinate system, that translates to the given <code>(posX, posY, posZ)</code> and aligns the local <code>-z</code> axis with <code>(dirX, dirY, dirZ)</code>. <p> This method is equivalent to calling: <code>translation(posX, posY, posZ).rotateTowards(dirX, dirY, dirZ, upX, upY, upZ)</code>
transpose3x3 Matrix3d transpose3x3(Matrix3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transpose3x3 Matrix4x3d transpose3x3(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transpose3x3 Matrix4x3d transpose3x3(): Transpose only the left 3x3 submatrix of this matrix and set the rest of the matrix elements to identity.
zero Matrix4x3d zero(): Set all the values within this matrix to 0.

Static variables

PLANE_NX int PLANE_NX;: Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>x=-1</code> when using the identity matrix.
PLANE_NY int PLANE_NY;: Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>y=-1</code> when using the identity matrix.
PLANE_NZ int PLANE_NZ;: Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>z=-1</code> when using the identity matrix.
PLANE_PX int PLANE_PX;: Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>x=1</code> when using the identity matrix.
PLANE_PY int PLANE_PY;: Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>y=1</code> when using the identity matrix.
PLANE_PZ int PLANE_PZ;: Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>z=1</code> when using the identity matrix.
PROPERTY_IDENTITY byte PROPERTY_IDENTITY;: Bit returned by {@link #properties()} to indicate that the matrix represents the identity transformation.
PROPERTY_ORTHONORMAL byte PROPERTY_ORTHONORMAL;: Bit returned by {@link #properties()} to indicate that the left 3x3 submatrix represents an orthogonal matrix (i.e. orthonormal basis).
PROPERTY_TRANSLATION byte PROPERTY_TRANSLATION;: Bit returned by {@link #properties()} to indicate that the matrix represents a pure translation transformation.

Variables

m00 double m00;: Undocumented in source.
m01 double m01;: Undocumented in source.
m02 double m02;: Undocumented in source.
m10 double m10;: Undocumented in source.
m11 double m11;: Undocumented in source.
m12 double m12;: Undocumented in source.
m20 double m20;: Undocumented in source.
m21 double m21;: Undocumented in source.
m22 double m22;: Undocumented in source.
m30 double m30;: Undocumented in source.
m31 double m31;: Undocumented in source.
m32 double m32;: Undocumented in source.
properties int properties;: Undocumented in source.

Meta

Source

See Implementation

matrix_4x3d structs

Matrix4x3d