Matrix4d

Contains the definition of a 4x4 Matrix 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> m03 m13 m23 m33<br>

@author Richard Greenlees @author Kai Burjack

struct Matrix4d {

static immutable

int PLANE_NX;

static immutable

int PLANE_PX;

static immutable

int PLANE_NY;

static immutable

int PLANE_PY;

static immutable

int PLANE_NZ;

static immutable

int PLANE_PZ;

static immutable

int CORNER_NXNYNZ;

static immutable

int CORNER_PXNYNZ;

static immutable

int CORNER_PXPYNZ;

static immutable

int CORNER_NXPYNZ;

static immutable

int CORNER_PXNYPZ;

static immutable

int CORNER_NXNYPZ;

static immutable

int CORNER_NXPYPZ;

static immutable

int CORNER_PXPYPZ;

static immutable

byte PROPERTY_PERSPECTIVE;

static immutable

byte PROPERTY_AFFINE;

static immutable

byte PROPERTY_IDENTITY;

static immutable

byte PROPERTY_TRANSLATION;

static immutable

byte PROPERTY_ORTHONORMAL;

int properties;

this(Matrix4d mat);

this(Matrix4x3d mat);

this(Matrix3d mat);

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

this(Vector4d col0, Vector4d col1, Vector4d col2, Vector4d col3);

Matrix4d assume(int properties);

Matrix4d determineProperties();

int getProperties();

Matrix4d setm00(double m00);

Matrix4d setm01(double m01);

Matrix4d setm02(double m02);

Matrix4d setm03(double m03);

Matrix4d setm10(double m10);

Matrix4d setm11(double m11);

Matrix4d setm12(double m12);

Matrix4d setm13(double m13);

Matrix4d setm20(double m20);

Matrix4d setm21(double m21);

Matrix4d setm22(double m22);

Matrix4d setm23(double m23);

Matrix4d setm30(double m30);

Matrix4d setm31(double m31);

Matrix4d setm32(double m32);

Matrix4d setm33(double m33);

Matrix4d _properties(int properties);

Matrix4d _m00(double m00);

Matrix4d _m01(double m01);

Matrix4d _m02(double m02);

Matrix4d _m03(double m03);

Matrix4d _m10(double m10);

Matrix4d _m11(double m11);

Matrix4d _m12(double m12);

Matrix4d _m13(double m13);

Matrix4d _m20(double m20);

Matrix4d _m21(double m21);

Matrix4d _m22(double m22);

Matrix4d _m23(double m23);

Matrix4d _m30(double m30);

Matrix4d _m31(double m31);

Matrix4d _m32(double m32);

Matrix4d _m33(double m33);

Matrix4d identity();

Matrix4d set(Matrix4d m);

Matrix4d setTransposed(Matrix4d m);

Matrix4d set(Matrix4x3d m);

Matrix4d set(Matrix3d mat);

Matrix4d set3x3(Matrix4d mat);

Matrix4d set4x3(Matrix4x3d mat);

Matrix4d set4x3(Matrix4d mat);

Matrix4d set(AxisAngle4d axisAngle);

Matrix4d set(Quaterniond q);

Matrix4d mul(Matrix4d right);

Matrix4d mul(Matrix4d right, Matrix4d dest);

Matrix4d mul0(Matrix4d right);

Matrix4d mul0(Matrix4d right, Matrix4d dest);

Matrix4d mul(double r00, double r01, double r02, double r03, double r10, double r11, double r12, double r13, double r20, double r21, double r22, double r23, double r30, double r31, double r32, double r33);

Matrix4d mul(double r00, double r01, double r02, double r03, double r10, double r11, double r12, double r13, double r20, double r21, double r22, double r23, double r30, double r31, double r32, double r33, Matrix4d dest);

Matrix4d mul3x3(double r00, double r01, double r02, double r10, double r11, double r12, double r20, double r21, double r22);

Matrix4d mul3x3(double r00, double r01, double r02, double r10, double r11, double r12, double r20, double r21, double r22, Matrix4d dest);

Matrix4d mulLocal(Matrix4d left);

Matrix4d mulLocal(Matrix4d left, Matrix4d dest);

Matrix4d mulLocalAffine(Matrix4d left);

Matrix4d mulLocalAffine(Matrix4d left, Matrix4d dest);

Matrix4d mul(Matrix4x3d right);

Matrix4d mul(Matrix4x3d right, Matrix4d dest);

Matrix4d mulPerspectiveAffine(Matrix4x3d view, Matrix4d dest);

Matrix4d mul(Matrix3x2d right);

Matrix4d mul(Matrix3x2d right, Matrix4d dest);

Matrix4d mulPerspectiveAffine(Matrix4d view);

Matrix4d mulPerspectiveAffine(Matrix4d view, Matrix4d dest);

Matrix4d mulAffineR(Matrix4d right);

Matrix4d mulAffineR(Matrix4d right, Matrix4d dest);

Matrix4d mulAffine(Matrix4d right);

Matrix4d mulAffine(Matrix4d right, Matrix4d dest);

Matrix4d mulTranslationAffine(Matrix4d right, Matrix4d dest);

Matrix4d mulOrthoAffine(Matrix4d view);

Matrix4d mulOrthoAffine(Matrix4d view, Matrix4d dest);

Matrix4d fma4x3(Matrix4d other, double otherFactor);

Matrix4d fma4x3(Matrix4d other, double otherFactor, Matrix4d dest);

Matrix4d add(Matrix4d other);

Matrix4d add(Matrix4d other, Matrix4d dest);

Matrix4d sub(Matrix4d subtrahend);

Matrix4d sub(Matrix4d subtrahend, Matrix4d dest);

Matrix4d mulComponentWise(Matrix4d other);

Matrix4d mulComponentWise(Matrix4d other, Matrix4d dest);

Matrix4d add4x3(Matrix4d other);

Matrix4d add4x3(Matrix4d other, Matrix4d dest);

Matrix4d sub4x3(Matrix4d subtrahend);

Matrix4d sub4x3(Matrix4d subtrahend, Matrix4d dest);

Matrix4d mul4x3ComponentWise(Matrix4d other);

Matrix4d mul4x3ComponentWise(Matrix4d other, Matrix4d dest);

Matrix4d set(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33);

Matrix4d set(double[] m);

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

Matrix4d set(Vector4d col0, Vector4d col1, Vector4d col2, Vector4d col3);

double determinant();

double determinant3x3();

double determinantAffine();

Matrix4d invert();

Matrix4d invert(Matrix4d dest);

Matrix4d invertPerspective(Matrix4d dest);

Matrix4d invertPerspective();

Matrix4d invertFrustum(Matrix4d dest);

Matrix4d invertFrustum();

Matrix4d invertOrtho(Matrix4d dest);

Matrix4d invertOrtho();

Matrix4d invertPerspectiveView(Matrix4d view, Matrix4d dest);

Matrix4d invertPerspectiveView(Matrix4x3d view, Matrix4d dest);

Matrix4d invertAffine(Matrix4d dest);

Matrix4d invertAffine();

Matrix4d transpose();

Matrix4d transpose(Matrix4d dest);

Matrix4d transpose3x3();

Matrix4d transpose3x3(Matrix4d dest);

Matrix3d transpose3x3(Matrix3d dest);

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

Matrix4d translation(Vector3d offset);

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

Matrix4d setTranslation(Vector3d xyz);

Vector3d getTranslation(Vector3d dest);

Vector3d getScale(Vector3d dest);

Matrix4d get(Matrix4d dest);

Matrix4x3d get4x3(Matrix4x3d dest);

Matrix3d get3x3(Matrix3d dest);

Quaterniond getUnnormalizedRotation(Quaterniond dest);

Quaterniond getNormalizedRotation(Quaterniond dest);

double[16] getDoubleArray();

double[16] getDoubleArray(double[16] dest, int offset);

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

double[] get(double[] dest);

Matrix4d zero();

Matrix4d scaling(double factor);

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

Matrix4d scaling(Vector3d xyz);

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

Matrix4d rotationX(double ang);

Matrix4d rotationY(double ang);

Matrix4d rotationZ(double ang);

Matrix4d rotationTowardsXY(double dirX, double dirY);

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

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

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

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

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

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

Matrix4d rotation(double angle, Vector3d axis);

Vector4d transform(Vector4d v);

Vector4d transform(Vector4d v, Vector4d dest);

Vector4d transform(double x, double y, double z, double w, Vector4d dest);

Vector4d transformTranspose(Vector4d v);

Vector4d transformTranspose(Vector4d v, Vector4d dest);

Vector4d transformTranspose(double x, double y, double z, double w, Vector4d dest);

Vector4d transformProject(Vector4d v);

Vector4d transformProject(Vector4d v, Vector4d dest);

Vector4d transformProject(double x, double y, double z, double w, Vector4d dest);

Vector3d transformProject(Vector3d v);

Vector3d transformProject(Vector3d v, Vector3d dest);

Vector3d transformProject(double x, double y, double z, Vector3d dest);

Vector3d transformProject(Vector4d v, Vector3d dest);

Vector3d transformProject(double x, double y, double z, double w, Vector3d dest);

Vector3d transformPosition(Vector3d dest);

Vector3d transformPosition(Vector3d v, Vector3d dest);

Vector3d transformPosition(double x, double y, double z, Vector3d dest);

Vector3d transformDirection(Vector3d dest);

Vector3d transformDirection(Vector3d v, Vector3d dest);

Vector3d transformDirection(double x, double y, double z, Vector3d dest);

Vector4d transformAffine(Vector4d dest);

Vector4d transformAffine(Vector4d v, Vector4d dest);

Vector4d transformAffine(double x, double y, double z, double w, Vector4d dest);

Matrix4d set3x3(Matrix3d mat);

Matrix4d scale(Vector3d xyz, Matrix4d dest);

Matrix4d scale(Vector3d xyz);

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

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

Matrix4d scale(double xyz, Matrix4d dest);

Matrix4d scale(double xyz);

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

Matrix4d scaleXY(double x, double y);

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

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

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

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

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

Matrix4d scaleLocal(double xyz, Matrix4d dest);

Matrix4d scaleLocal(double xyz);

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

Matrix4d scaleAroundLocal(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4d dest);

Matrix4d scaleAroundLocal(double sx, double sy, double sz, double ox, double oy, double oz);

Matrix4d scaleAroundLocal(double factor, double ox, double oy, double oz);

Matrix4d scaleAroundLocal(double factor, double ox, double oy, double oz, Matrix4d dest);

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

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

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

Matrix4d rotateAffine(double ang, double x, double y, double z, Matrix4d dest);

Matrix4d rotateAffine(double ang, double x, double y, double z);

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

Matrix4d rotateAroundAffine(Quaterniond quat, double ox, double oy, double oz, Matrix4d dest);

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

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

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

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

Matrix4d rotateAroundLocal(Quaterniond quat, double ox, double oy, double oz, Matrix4d dest);

Matrix4d rotateAroundLocal(Quaterniond quat, double ox, double oy, double oz);

Matrix4d translate(Vector3d offset);

Matrix4d translate(Vector3d offset, Matrix4d dest);

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

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

Matrix4d translateLocal(Vector3d offset);

Matrix4d translateLocal(Vector3d offset, Matrix4d dest);

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

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

Matrix4d rotateLocalX(double ang, Matrix4d dest);

Matrix4d rotateLocalX(double ang);

Matrix4d rotateLocalY(double ang, Matrix4d dest);

Matrix4d rotateLocalY(double ang);

Matrix4d rotateLocalZ(double ang, Matrix4d dest);

Matrix4d rotateLocalZ(double ang);

Matrix4d rotateX(double ang, Matrix4d dest);

Matrix4d rotateX(double ang);

Matrix4d rotateY(double ang, Matrix4d dest);

Matrix4d rotateY(double ang);

Matrix4d rotateZ(double ang, Matrix4d dest);

Matrix4d rotateZ(double ang);

Matrix4d rotateTowardsXY(double dirX, double dirY);

Matrix4d rotateTowardsXY(double dirX, double dirY, Matrix4d dest);

Matrix4d rotateXYZ(Vector3d angles);

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

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

Matrix4d rotateAffineXYZ(double angleX, double angleY, double angleZ);

Matrix4d rotateAffineXYZ(double angleX, double angleY, double angleZ, Matrix4d dest);

Matrix4d rotateZYX(Vector3d angles);

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

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

Matrix4d rotateAffineZYX(double angleZ, double angleY, double angleX);

Matrix4d rotateAffineZYX(double angleZ, double angleY, double angleX, Matrix4d dest);

Matrix4d rotateYXZ(Vector3d angles);

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

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

Matrix4d rotateAffineYXZ(double angleY, double angleX, double angleZ);

Matrix4d rotateAffineYXZ(double angleY, double angleX, double angleZ, Matrix4d dest);

Matrix4d rotation(AxisAngle4d angleAxis);

Matrix4d rotation(Quaterniond quat);

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

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

Matrix4d translationRotateScale(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double scale);

Matrix4d translationRotateScale(Vector3d translation, Quaterniond quat, double scale);

Matrix4d translationRotateScaleInvert(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz);

Matrix4d translationRotateScaleInvert(Vector3d translation, Quaterniond quat, Vector3d scale);

Matrix4d translationRotateScaleInvert(Vector3d translation, Quaterniond quat, double scale);

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

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

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

Matrix4d translationRotate(Vector3d translation, Quaterniond quat);

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

Matrix4d rotate(Quaterniond quat, Matrix4d dest);

Matrix4d rotate(Quaterniond quat);

Matrix4d rotateAffine(Quaterniond quat, Matrix4d dest);

Matrix4d rotateAffine(Quaterniond quat);

Matrix4d rotateTranslation(Quaterniond quat, Matrix4d dest);

Matrix4d rotateLocal(Quaterniond quat, Matrix4d dest);

Matrix4d rotateLocal(Quaterniond quat);

Matrix4d rotate(AxisAngle4d axisAngle);

Matrix4d rotate(AxisAngle4d axisAngle, Matrix4d dest);

Matrix4d rotate(double angle, Vector3d axis);

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

Vector4d getRow(int row, Vector4d dest);

Vector3d getRow(int row, Vector3d dest);

Matrix4d setRow(int row, Vector4d src);

Vector4d getColumn(int column, Vector4d dest);

Vector3d getColumn(int column, Vector3d dest);

Matrix4d setColumn(int column, Vector4d src);

double get(int column, int row);

Matrix4d set(int column, int row, double value);

double getRowColumn(int row, int column);

Matrix4d setRowColumn(int row, int column, double value);

Matrix4d normal();

Matrix4d normal(Matrix4d dest);

Matrix3d normal(Matrix3d dest);

Matrix4d cofactor3x3();

Matrix3d cofactor3x3(Matrix3d dest);

Matrix4d cofactor3x3(Matrix4d dest);

Matrix4d normalize3x3();

Matrix4d normalize3x3(Matrix4d dest);

Matrix3d normalize3x3(Matrix3d dest);

Vector4d unproject(double winX, double winY, double winZ, int[] viewport, Vector4d dest);

Vector3d unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest);

Vector4d unproject(Vector3d winCoords, int[] viewport, Vector4d dest);

Vector3d unproject(Vector3d winCoords, int[] viewport, Vector3d dest);

Matrix4d unprojectRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest);

Matrix4d unprojectRay(Vector2d winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest);

Vector4d unprojectInv(Vector3d winCoords, int[] viewport, Vector4d dest);

Vector4d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector4d dest);

Vector3d unprojectInv(Vector3d winCoords, int[] viewport, Vector3d dest);

Vector3d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest);

Matrix4d unprojectInvRay(Vector2d winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest);

Matrix4d unprojectInvRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest);

Vector4d project(double x, double y, double z, int[] viewport, Vector4d winCoordsDest);

Vector3d project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest);

Vector4d project(Vector3d position, int[] viewport, Vector4d dest);

Vector3d project(Vector3d position, int[] viewport, Vector3d dest);

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

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

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

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

Matrix4d reflect(Vector3d normal, Vector3d point);

Matrix4d reflect(Quaterniond orientation, Vector3d point);

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

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

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

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

Matrix4d reflection(Vector3d normal, Vector3d point);

Matrix4d reflection(Quaterniond orientation, Vector3d point);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Matrix4d lookAlong(Vector3d dir, Vector3d up);

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

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

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

Matrix4d setLookAlong(Vector3d dir, Vector3d up);

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

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

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

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

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

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

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

Matrix4d lookAtPerspective(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d dest);

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

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

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

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

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

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

Matrix4d lookAtPerspectiveLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d dest);

Matrix4d tile(int x, int y, int w, int h);

Matrix4d tile(int x, int y, int w, int h, Matrix4d dest);

Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, Matrix4d dest);

Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne);

Matrix4d perspective(double fovy, double aspect, double zNear, double zFar);

Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, Matrix4d dest);

Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne);

Matrix4d perspectiveRect(double width, double height, double zNear, double zFar);

Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, Matrix4d dest);

Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne);

Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar);

Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne);

Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar);

Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, Matrix4d dest);

Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne);

Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar);

Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, Matrix4d dest);

Matrix4d setPerspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne);

Matrix4d setPerspective(double fovy, double aspect, double zNear, double zFar);

Matrix4d setPerspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne);

Matrix4d setPerspectiveRect(double width, double height, double zNear, double zFar);

Matrix4d setPerspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar);

Matrix4d setPerspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne);

Matrix4d setPerspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar);

Matrix4d setPerspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne);

Matrix4d setPerspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar);

Matrix4d setPerspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne);

Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne);

Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, Matrix4d dest);

Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar);

Matrix4d setPerspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne);

Matrix4d setPerspectiveLH(double fovy, double aspect, double zNear, double zFar);

Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest);

Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4d setFrustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4d setFrustum(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d dest);

Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest);

Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4d setFrustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne);

Matrix4d setFrustumLH(double left, double right, double bottom, double top, double zNear, double zFar);

Matrix4d setFromIntrinsic(double alphaX, double alphaY, double gamma, double u0, double v0, int imgWidth, int imgHeight, double near, double far);

Vector4d frustumPlane(int plane, Vector4d dest);

Vector3d frustumCorner(int corner, Vector3d dest);

Vector3d perspectiveOrigin(Vector3d dest);

Vector3d perspectiveInvOrigin(Vector3d dest);

double perspectiveFov();

double perspectiveNear();

double perspectiveFar();

Vector3d frustumRayDir(double x, double y, Vector3d 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 originAffine(Vector3d dest);

Vector3d origin(Vector3d dest);

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

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

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

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

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

Matrix4d shadow(Vector4d light, Matrix4d planeTransform);

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

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

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

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

Matrix4d billboardSpherical(Vector3d objPos, Vector3d targetPos);

int hashCode();

bool equals(Matrix4d m, double delta);

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

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

bool isAffine();

Matrix4d swap(Matrix4d other);

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

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

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

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

Matrix4d frustumAabb(Vector3d min, Vector3d max);

Matrix4d projectedGridRange(Matrix4d projector, double sLower, double sUpper, Matrix4d dest);

Matrix4d perspectiveFrustumSlice(double near, double far, Matrix4d dest);

Matrix4d orthoCrop(Matrix4d view, Matrix4d dest);

Matrix4d trapezoidCrop(double p0x, double p0y, double p1x, double p1y, double p2x, double p2y, double p3x, double p3y);

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

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

Matrix4d lerp(Matrix4d other, double t);

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

Matrix4d rotateTowards(Vector3d direction, Vector3d up, Matrix4d dest);

Matrix4d rotateTowards(Vector3d direction, Vector3d up);

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

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

Matrix4d rotationTowards(Vector3d dir, Vector3d up);

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

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

Matrix4d 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);

Matrix4d affineSpan(Vector3d corner, Vector3d xDir, Vector3d yDir, Vector3d zDir);

bool testPoint(double x, double y, double z);

bool testSphere(double x, double y, double z, double r);

bool testAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ);

Matrix4d obliqueZ(double a, double b);

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

static void projViewFromRectangle(Vector3d eye, Vector3d p, Vector3d x, Vector3d y, double nearFarDist, bool zeroToOne, Matrix4d projDest, Matrix4d viewDest);

Matrix4d withLookAtUp(Vector3d up);

Matrix4d withLookAtUp(Vector3d up, Matrix4d dest);

Matrix4d withLookAtUp(double upX, double upY, double upZ);

Matrix4d withLookAtUp(double upX, double upY, double upZ, Matrix4d dest);

Matrix4d mapXZY();

Matrix4d mapXZY(Matrix4d dest);

Matrix4d mapXZnY();

Matrix4d mapXZnY(Matrix4d dest);

Matrix4d mapXnYnZ();

Matrix4d mapXnYnZ(Matrix4d dest);

Matrix4d mapXnZY();

Matrix4d mapXnZY(Matrix4d dest);

Matrix4d mapXnZnY();

Matrix4d mapXnZnY(Matrix4d dest);

Matrix4d mapYXZ();

Matrix4d mapYXZ(Matrix4d dest);

Matrix4d mapYXnZ();

Matrix4d mapYXnZ(Matrix4d dest);

Matrix4d mapYZX();

Matrix4d mapYZX(Matrix4d dest);

Matrix4d mapYZnX();

Matrix4d mapYZnX(Matrix4d dest);

Matrix4d mapYnXZ();

Matrix4d mapYnXZ(Matrix4d dest);

Matrix4d mapYnXnZ();

Matrix4d mapYnXnZ(Matrix4d dest);

Matrix4d mapYnZX();

Matrix4d mapYnZX(Matrix4d dest);

Matrix4d mapYnZnX();

Matrix4d mapYnZnX(Matrix4d dest);

Matrix4d mapZXY();

Matrix4d mapZXY(Matrix4d dest);

Matrix4d mapZXnY();

Matrix4d mapZXnY(Matrix4d dest);

Matrix4d mapZYX();

Matrix4d mapZYX(Matrix4d dest);

Matrix4d mapZYnX();

Matrix4d mapZYnX(Matrix4d dest);

Matrix4d mapZnXY();

Matrix4d mapZnXY(Matrix4d dest);

Matrix4d mapZnXnY();

Matrix4d mapZnXnY(Matrix4d dest);

Matrix4d mapZnYX();

Matrix4d mapZnYX(Matrix4d dest);

Matrix4d mapZnYnX();

Matrix4d mapZnYnX(Matrix4d dest);

Matrix4d mapnXYnZ();

Matrix4d mapnXYnZ(Matrix4d dest);

Matrix4d mapnXZY();

Matrix4d mapnXZY(Matrix4d dest);

Matrix4d mapnXZnY();

Matrix4d mapnXZnY(Matrix4d dest);

Matrix4d mapnXnYZ();

Matrix4d mapnXnYZ(Matrix4d dest);

Matrix4d mapnXnYnZ();

Matrix4d mapnXnYnZ(Matrix4d dest);

Matrix4d mapnXnZY();

Matrix4d mapnXnZY(Matrix4d dest);

Matrix4d mapnXnZnY();

Matrix4d mapnXnZnY(Matrix4d dest);

Matrix4d mapnYXZ();

Matrix4d mapnYXZ(Matrix4d dest);

Matrix4d mapnYXnZ();

Matrix4d mapnYXnZ(Matrix4d dest);

Matrix4d mapnYZX();

Matrix4d mapnYZX(Matrix4d dest);

Matrix4d mapnYZnX();

Matrix4d mapnYZnX(Matrix4d dest);

Matrix4d mapnYnXZ();

Matrix4d mapnYnXZ(Matrix4d dest);

Matrix4d mapnYnXnZ();

Matrix4d mapnYnXnZ(Matrix4d dest);

Matrix4d mapnYnZX();

Matrix4d mapnYnZX(Matrix4d dest);

Matrix4d mapnYnZnX();

Matrix4d mapnYnZnX(Matrix4d dest);

Matrix4d mapnZXY();

Matrix4d mapnZXY(Matrix4d dest);

Matrix4d mapnZXnY();

Matrix4d mapnZXnY(Matrix4d dest);

Matrix4d mapnZYX();

Matrix4d mapnZYX(Matrix4d dest);

Matrix4d mapnZYnX();

Matrix4d mapnZYnX(Matrix4d dest);

Matrix4d mapnZnXY();

Matrix4d mapnZnXY(Matrix4d dest);

Matrix4d mapnZnXnY();

Matrix4d mapnZnXnY(Matrix4d dest);

Matrix4d mapnZnYX();

Matrix4d mapnZnYX(Matrix4d dest);

Matrix4d mapnZnYnX();

Matrix4d mapnZnYnX(Matrix4d dest);

Matrix4d negateX();

Matrix4d negateX(Matrix4d dest);

Matrix4d negateY();

Matrix4d negateY(Matrix4d dest);

Matrix4d negateZ();

Matrix4d negateZ(Matrix4d dest);

bool isFinite();

}

Constructors

this this(Matrix4d mat): Create a new {@link Matrix4d} and make it a copy of the given matrix.
this this(Matrix4x3d mat): Create a new {@link Matrix4d} and set its upper 4x3 submatrix to the given matrix <code>mat</code> and all other elements to identity.
this this(Matrix3d mat): Create a new {@link Matrix4d} by setting its uppper 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 m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33): Create a new 4x4 matrix using the supplied double values. <p> The matrix layout will be:<br><br> m00, m10, m20, m30<br> m01, m11, m21, m31<br> m02, m12, m22, m32<br> m03, m13, m23, m33
this this(Vector4d col0, Vector4d col1, Vector4d col2, Vector4d col3): Create a new {@link Matrix4d} and initialize its four columns using the supplied vectors.

Members

Functions

_m00 Matrix4d _m00(double m00): Set the value of the matrix element at column 0 and row 0 without updating the properties of the matrix.
_m01 Matrix4d _m01(double m01): Set the value of the matrix element at column 0 and row 1 without updating the properties of the matrix.
_m02 Matrix4d _m02(double m02): Set the value of the matrix element at column 0 and row 2 without updating the properties of the matrix.
_m03 Matrix4d _m03(double m03): Set the value of the matrix element at column 0 and row 3 without updating the properties of the matrix.
_m10 Matrix4d _m10(double m10): Set the value of the matrix element at column 1 and row 0 without updating the properties of the matrix.
_m11 Matrix4d _m11(double m11): Set the value of the matrix element at column 1 and row 1 without updating the properties of the matrix.
_m12 Matrix4d _m12(double m12): Set the value of the matrix element at column 1 and row 2 without updating the properties of the matrix.
_m13 Matrix4d _m13(double m13): Set the value of the matrix element at column 1 and row 3 without updating the properties of the matrix.
_m20 Matrix4d _m20(double m20): Set the value of the matrix element at column 2 and row 0 without updating the properties of the matrix.
_m21 Matrix4d _m21(double m21): Set the value of the matrix element at column 2 and row 1 without updating the properties of the matrix.
_m22 Matrix4d _m22(double m22): Set the value of the matrix element at column 2 and row 2 without updating the properties of the matrix.
_m23 Matrix4d _m23(double m23): Set the value of the matrix element at column 2 and row 3 without updating the properties of the matrix.
_m30 Matrix4d _m30(double m30): Set the value of the matrix element at column 3 and row 0 without updating the properties of the matrix.
_m31 Matrix4d _m31(double m31): Set the value of the matrix element at column 3 and row 1 without updating the properties of the matrix.
_m32 Matrix4d _m32(double m32): Set the value of the matrix element at column 3 and row 2 without updating the properties of the matrix.
_m33 Matrix4d _m33(double m33): Set the value of the matrix element at column 3 and row 3 without updating the properties of the matrix.
_properties Matrix4d _properties(int properties): Undocumented in source. Be warned that the author may not have intended to support it.
add Matrix4d add(Matrix4d other, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
add Matrix4d add(Matrix4d other): Component-wise add <code>this</code> and <code>other</code>.
add4x3 Matrix4d add4x3(Matrix4d other, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
add4x3 Matrix4d add4x3(Matrix4d other): Component-wise add the upper 4x3 submatrices of <code>this</code> and <code>other</code>.
affineSpan Matrix4d affineSpan(Vector3d corner, Vector3d xDir, Vector3d yDir, Vector3d zDir): Compute the extents of the coordinate system before this {@link #isAffine() affine} transformation was applied and store the resulting corner coordinates in <code>corner</code> and the span vectors in <code>xDir</code>, <code>yDir</code> and <code>zDir</code>. <p> That means, given the maximum extents of the coordinate system between <code>[-1..+1]</code> in all dimensions, this method returns one corner and the length and direction of the three base axis vectors in the coordinate system before this transformation is applied, which transforms into the corner coordinates <code>[-1, +1]</code>. <p> This method is equivalent to computing at least three adjacent corners using {@link #frustumCorner(int, Vector3d)} and subtracting them to obtain the length and direction of the span vectors.
arcball Matrix4d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
arcball Matrix4d arcball(double radius, Vector3d center, double angleX, double angleY, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
arcball Matrix4d 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 Matrix4d 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>
assume Matrix4d assume(int properties): Assume the given properties about this matrix. <p> Use one or multiple of 0, {@link Matrix4d#PROPERTY_IDENTITY}, {@link Matrix4d#PROPERTY_TRANSLATION}, {@link Matrix4d#PROPERTY_AFFINE}, {@link Matrix4d#PROPERTY_PERSPECTIVE}, {@link Matrix4fc#PROPERTY_ORTHONORMAL}.
billboardCylindrical Matrix4d 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 Matrix4d 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(ref Vector3d, Vector3d)}.
billboardSpherical Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.
cofactor3x3 Matrix4d cofactor3x3(): Compute the cofactor matrix of the upper 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 Matrix3d cofactor3x3(Matrix3d dest): Compute the cofactor matrix of the upper 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.
cofactor3x3 Matrix4d cofactor3x3(Matrix4d dest): Compute the cofactor matrix of the upper 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(Matrix4d)} 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.
determinant3x3 double determinant3x3(): Undocumented in source. Be warned that the author may not have intended to support it.
determinantAffine double determinantAffine(): Undocumented in source. Be warned that the author may not have intended to support it.
determineProperties Matrix4d determineProperties(): Compute and set the matrix properties returned by {@link #properties()} based on the current matrix element values.
equals bool equals(Matrix4d m, double delta): Undocumented in source. Be warned that the author may not have intended to support it.
fma4x3 Matrix4d fma4x3(Matrix4d other, double otherFactor, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
fma4x3 Matrix4d fma4x3(Matrix4d other, double otherFactor): Component-wise add the upper 4x3 submatrices of <code>this</code> and <code>other</code> by first multiplying each component of <code>other</code>'s 4x3 submatrix by <code>otherFactor</code> and adding that result to <code>this</code>. <p> The matrix <code>other</code> will not be changed.
frustum Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double, bool) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustum Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest): Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustum Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double, bool) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustum Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar): Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustumAabb Matrix4d frustumAabb(Vector3d min, Vector3d max): Compute the axis-aligned bounding box of the frustum described by <code>this</code> matrix and store the minimum corner coordinates in the given <code>min</code> and the maximum corner coordinates in the given <code>max</code> vector. <p> The matrix <code>this</code> is assumed to be the {@link #invert() inverse} of the origial view-projection matrix for which to compute the axis-aligned bounding box in world-space. <p> The axis-aligned bounding box of the unit frustum is <code>(-1, -1, -1)</code>, <code>(1, 1, 1)</code>.
frustumCorner Vector3d frustumCorner(int corner, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
frustumLH Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Apply an arbitrary perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustumLH(double, double, double, double, double, double, bool) setFrustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustumLH Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Apply an arbitrary perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustumLH(double, double, double, double, double, double, bool) setFrustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustumLH Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest): Apply an arbitrary perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustumLH(double, double, double, double, double, double) setFrustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustumLH Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar): Apply an arbitrary perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustumLH(double, double, double, double, double, double) setFrustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
frustumPlane Vector4d frustumPlane(int plane, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
frustumRayDir Vector3d frustumRayDir(double x, double y, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
get Matrix4d get(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
get double get(int column, int row): Undocumented in source. Be warned that the author may not have intended to support it.
get double[] get(double[] dest): Undocumented in source. Be warned that the author may not have intended to support it.
get double[] get(double[] dest, int offset): Undocumented in source. Be warned that the author may not have intended to support it.
get3x3 Matrix3d get3x3(Matrix3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
get4x3 Matrix4x3d get4x3(Matrix4x3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
getColumn Vector4d getColumn(int column, Vector4d dest): 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.
getDoubleArray double[16] getDoubleArray(double[16] dest, int offset): Undocumented in source. Be warned that the author may not have intended to support it.
getDoubleArray double[16] getDoubleArray(): 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.
getProperties int getProperties(): Undocumented in source. Be warned that the author may not have intended to support it.
getRow Vector3d getRow(int row, Vector3d 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.
getRowColumn double getRowColumn(int row, int column): 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.
getUnnormalizedRotation Quaterniond getUnnormalizedRotation(Quaterniond dest): 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 Matrix4d 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 #perspective(double, double, double, double) perspective}, {@link #frustum(double, double, double, double, double, double) frustum}, {@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 #setPerspective(double, double, double, double) setPerspective}, {@link #setFrustum(double, double, double, double, double, double) setFrustum}, {@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 Matrix4d invert(): Invert this matrix. <p> If <code>this</code> matrix represents an {@link #isAffine() affine} transformation, such as translation, rotation, scaling and shearing, and thus its last row is equal to <code>(0, 0, 0, 1)</code>, then {@link #invertAffine()} can be used instead of this method.
invert Matrix4d invert(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
invertAffine Matrix4d invertAffine(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
invertAffine Matrix4d invertAffine(): Invert this matrix by assuming that it is an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>).
invertFrustum Matrix4d invertFrustum(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
invertFrustum Matrix4d invertFrustum(): If <code>this</code> is an arbitrary perspective projection matrix obtained via one of the {@link #frustum(double, double, double, double, double, double) frustum()} methods or via {@link #setFrustum(double, double, double, double, double, double) setFrustum()}, then this method builds the inverse of <code>this</code>. <p> This method can be used to quickly obtain the inverse of a perspective projection matrix. <p> If this matrix represents a symmetric perspective frustum transformation, as obtained via {@link #perspective(double, double, double, double) perspective()}, then {@link #invertPerspective()} should be used instead.
invertOrtho Matrix4d invertOrtho(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
invertOrtho Matrix4d invertOrtho(): Invert <code>this</code> orthographic projection matrix. <p> This method can be used to quickly obtain the inverse of an orthographic projection matrix.
invertPerspective Matrix4d invertPerspective(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
invertPerspective Matrix4d invertPerspective(): If <code>this</code> is a perspective projection matrix obtained via one of the {@link #perspective(double, double, double, double) perspective()} methods or via {@link #setPerspective(double, double, double, double) setPerspective()}, that is, if <code>this</code> is a symmetrical perspective frustum transformation, then this method builds the inverse of <code>this</code>. <p> This method can be used to quickly obtain the inverse of a perspective projection matrix when being obtained via {@link #perspective(double, double, double, double) perspective()}.
invertPerspectiveView Matrix4d invertPerspectiveView(Matrix4d view, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
invertPerspectiveView Matrix4d invertPerspectiveView(Matrix4x3d view, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
isAffine bool isAffine(): 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 Matrix4d lerp(Matrix4d 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 Matrix4d lerp(Matrix4d other, double t, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
lookAlong Matrix4d 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(ref 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(ref Vector3d, Vector3d) setLookAlong()}.
lookAlong Matrix4d lookAlong(Vector3d dir, Vector3d up, Matrix4d 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(ref 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(ref Vector3d, Vector3d) setLookAlong()}.
lookAlong Matrix4d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4d 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 Matrix4d 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()}
lookAt Matrix4d lookAt(Vector3d eye, Vector3d center, Vector3d up, Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.
lookAt Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.
lookAt Matrix4d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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 Matrix4d 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()}.
lookAtLH Matrix4d lookAtLH(Vector3d eye, Vector3d center, Vector3d up, Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.
lookAtLH Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.
lookAtLH Matrix4d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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 Matrix4d 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()}.
lookAtPerspective Matrix4d lookAtPerspective(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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> This method assumes <code>this</code> to be a perspective transformation, obtained via {@link #frustum(double, double, double, double, double, double) frustum()} or {@link #perspective(double, double, double, double) perspective()} or one of their overloads. <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()}.
lookAtPerspectiveLH Matrix4d lookAtPerspectiveLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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> This method assumes <code>this</code> to be a perspective transformation, obtained via {@link #frustumLH(double, double, double, double, double, double) frustumLH()} or {@link #perspectiveLH(double, double, double, double) perspectiveLH()} or one of their overloads. <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()}.
mapXZY Matrix4d mapXZY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 </pre>
mapXZY Matrix4d mapXZY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXZnY Matrix4d mapXZnY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 -1 0 0 1 0 0 0 0 0 1 </pre>
mapXZnY Matrix4d mapXZnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXnYnZ Matrix4d mapXnYnZ(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 -1 0 0 0 0 -1 0 0 0 0 1 </pre>
mapXnYnZ Matrix4d mapXnYnZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXnZY Matrix4d mapXnZY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 1 0 0 -1 0 0 0 0 0 1 </pre>
mapXnZY Matrix4d mapXnZY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapXnZnY Matrix4d mapXnZnY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 -1 0 0 -1 0 0 0 0 0 1 </pre>
mapXnZnY Matrix4d mapXnZnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYXZ Matrix4d mapYXZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 </pre>
mapYXZ Matrix4d mapYXZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYXnZ Matrix4d mapYXnZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 1 0 0 0 0 0 -1 0 0 0 0 1 </pre>
mapYXnZ Matrix4d mapYXnZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYZX Matrix4d mapYZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 1 0 0 0 0 1 0 0 0 0 0 1 </pre>
mapYZX Matrix4d mapYZX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYZnX Matrix4d mapYZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 1 0 0 0 0 1 0 0 0 0 0 1 </pre>
mapYZnX Matrix4d mapYZnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnXZ Matrix4d mapYnXZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 </pre>
mapYnXZ Matrix4d mapYnXZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnXnZ Matrix4d mapYnXnZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnXnZ Matrix4d mapYnXnZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 1 0 0 0 0 0 -1 0 0 0 0 1 </pre>
mapYnZX Matrix4d mapYnZX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnZX Matrix4d mapYnZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 1 0 0 0 0 -1 0 0 0 0 0 1 </pre>
mapYnZnX Matrix4d mapYnZnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapYnZnX Matrix4d mapYnZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 1 0 0 0 0 -1 0 0 0 0 0 1 </pre>
mapZXY Matrix4d mapZXY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZXY Matrix4d mapZXY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 </pre>
mapZXnY Matrix4d mapZXnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZXnY Matrix4d mapZXnY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 -1 0 1 0 0 0 0 0 0 1 </pre>
mapZYX Matrix4d mapZYX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZYX Matrix4d mapZYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 1 </pre>
mapZYnX Matrix4d mapZYnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZYnX Matrix4d mapZYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 1 0 0 1 0 0 0 0 0 0 1 </pre>
mapZnXY Matrix4d mapZnXY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnXY Matrix4d mapZnXY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 </pre>
mapZnXnY Matrix4d mapZnXnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnXnY Matrix4d mapZnXnY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 -1 0 1 0 0 0 0 0 0 1 </pre>
mapZnYX Matrix4d mapZnYX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnYX Matrix4d mapZnYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 -1 0 0 1 0 0 0 0 0 0 1 </pre>
mapZnYnX Matrix4d mapZnYnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapZnYnX Matrix4d mapZnYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 -1 0 0 1 0 0 0 0 0 0 1 </pre>
mapnXYnZ Matrix4d mapnXYnZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXYnZ Matrix4d mapnXYnZ(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 1 0 0 0 0 -1 0 0 0 0 1 </pre>
mapnXZY Matrix4d mapnXZY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 </pre>
mapnXZY Matrix4d mapnXZY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXZnY Matrix4d mapnXZnY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 -1 0 0 1 0 0 0 0 0 1 </pre>
mapnXZnY Matrix4d mapnXZnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnYZ Matrix4d mapnXnYZ(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 -1 0 0 0 0 1 0 0 0 0 1 </pre>
mapnXnYZ Matrix4d mapnXnYZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnYnZ Matrix4d mapnXnYnZ(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 -1 0 0 0 0 -1 0 0 0 0 1 </pre>
mapnXnYnZ Matrix4d mapnXnYnZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnZY Matrix4d mapnXnZY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnZY Matrix4d mapnXnZY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 1 0 0 -1 0 0 0 0 0 1 </pre>
mapnXnZnY Matrix4d mapnXnZnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnZnY Matrix4d mapnXnZnY(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 -1 0 0 -1 0 0 0 0 0 1 </pre>
mapnYXZ Matrix4d mapnYXZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 -1 0 0 0 0 0 1 0 0 0 0 1 </pre>
mapnYXZ Matrix4d mapnYXZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYXnZ Matrix4d mapnYXnZ(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 -1 0 0 0 0 0 -1 0 0 0 0 1 </pre>
mapnYXnZ Matrix4d mapnYXnZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYZX Matrix4d mapnYZX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYZX Matrix4d mapnYZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 -1 0 0 0 0 1 0 0 0 0 0 1 </pre>
mapnYZnX Matrix4d mapnYZnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYZnX Matrix4d mapnYZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 -1 0 0 0 0 1 0 0 0 0 0 1 </pre>
mapnYnXZ Matrix4d mapnYnXZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 -1 0 0 0 0 0 1 0 0 0 0 1 </pre>
mapnYnXZ Matrix4d mapnYnXZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnXnZ Matrix4d mapnYnXnZ(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 -1 0 0 0 0 0 -1 0 0 0 0 1 </pre>
mapnYnXnZ Matrix4d mapnYnXnZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnZX Matrix4d mapnYnZX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 -1 0 0 0 0 -1 0 0 0 0 0 1 </pre>
mapnYnZX Matrix4d mapnYnZX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnZnX Matrix4d mapnYnZnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 -1 0 0 0 0 -1 0 0 0 0 0 1 </pre>
mapnYnZnX Matrix4d mapnYnZnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZXY Matrix4d mapnZXY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 1 0 -1 0 0 0 0 0 0 1 </pre>
mapnZXY Matrix4d mapnZXY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZXnY Matrix4d mapnZXnY(): Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 -1 0 -1 0 0 0 0 0 0 1 </pre>
mapnZXnY Matrix4d mapnZXnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZYX Matrix4d mapnZYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 1 0 0 -1 0 0 0 0 0 0 1 </pre>
mapnZYX Matrix4d mapnZYX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZYnX Matrix4d mapnZYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 1 0 0 -1 0 0 0 0 0 0 1 </pre>
mapnZYnX Matrix4d mapnZYnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnXY Matrix4d mapnZnXY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 1 0 -1 0 0 0 0 0 0 1 </pre>
mapnZnXY Matrix4d mapnZnXY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnXnY Matrix4d mapnZnXnY(): Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 -1 0 -1 0 0 0 0 0 0 1 </pre>
mapnZnXnY Matrix4d mapnZnXnY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnYX Matrix4d mapnZnYX(): Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 -1 0 0 -1 0 0 0 0 0 0 1 </pre>
mapnZnYX Matrix4d mapnZnYX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnYnX Matrix4d mapnZnYnX(): Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 -1 0 0 -1 0 0 0 0 0 0 1 </pre>
mapnZnYnX Matrix4d mapnZnYnX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul Matrix4d mul(Matrix3x2d right, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul Matrix4d mul(Matrix3x2d right): Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>this</code>. <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 Matrix4d mul(Matrix4x3d right, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul Matrix4d mul(Matrix4x3d right): Multiply this matrix by the supplied <code>right</code> matrix. <p> The last row of the <code>right</code> matrix is assumed to be <code>(0, 0, 0, 1)</code>. <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 Matrix4d mul(double r00, double r01, double r02, double r03, double r10, double r11, double r12, double r13, double r20, double r21, double r22, double r23, double r30, double r31, double r32, double r33, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul Matrix4d mul(double r00, double r01, double r02, double r03, double r10, double r11, double r12, double r13, double r20, double r21, double r22, double r23, double r30, double r31, double r32, double r33): Multiply this matrix by the matrix with the supplied elements. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix whose elements are supplied via the parameters, 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 Matrix4d mul(Matrix4d right, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul Matrix4d mul(Matrix4d 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!
mul0 Matrix4d mul0(Matrix4d right, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul0 Matrix4d mul0(Matrix4d 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! <p> This method neither assumes nor checks for any matrix properties of <code>this</code> or <code>right</code> and will always perform a complete 4x4 matrix multiplication. This method should only be used whenever the multiplied matrices do not have any properties for which there are optimized multiplication methods available.
mul3x3 Matrix4d mul3x3(double r00, double r01, double r02, double r10, double r11, double r12, double r20, double r21, double r22, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mul3x3 Matrix4d mul3x3(double r00, double r01, double r02, double r10, double r11, double r12, double r20, double r21, double r22): Multiply this matrix by the 3x3 matrix with the supplied elements expanded to a 4x4 matrix with all other matrix elements set to identity. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix whose elements are supplied via the parameters, 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!
mul4x3ComponentWise Matrix4d mul4x3ComponentWise(Matrix4d other): Component-wise multiply the upper 4x3 submatrices of <code>this</code> by <code>other</code>.
mul4x3ComponentWise Matrix4d mul4x3ComponentWise(Matrix4d other, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulAffine Matrix4d mulAffine(Matrix4d right, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulAffine Matrix4d mulAffine(Matrix4d right): Multiply this matrix by the supplied <code>right</code> matrix, both of which are assumed to be {@link #isAffine() affine}, and store the result in <code>this</code>. <p> This method assumes that <code>this</code> matrix and the given <code>right</code> matrix both represent an {@link #isAffine() affine} transformation (i.e. their last rows are equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrices only represent affine transformations, such as translation, rotation, scaling and shearing (in any combination). <p> This method will not modify either the last row of <code>this</code> or the last row of <code>right</code>. <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!
mulAffineR Matrix4d mulAffineR(Matrix4d right, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulAffineR Matrix4d mulAffineR(Matrix4d right): Multiply this matrix by the supplied <code>right</code> matrix, which is assumed to be {@link #isAffine() affine}, and store the result in <code>this</code>. <p> This method assumes that the given <code>right</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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!
mulComponentWise Matrix4d mulComponentWise(Matrix4d other, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulComponentWise Matrix4d mulComponentWise(Matrix4d other): Component-wise multiply <code>this</code> by <code>other</code>.
mulLocal Matrix4d mulLocal(Matrix4d left, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulLocal Matrix4d mulLocal(Matrix4d left): Pre-multiply this matrix by the supplied <code>left</code> matrix and store the result in <code>this</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the <code>left</code> matrix, then the new matrix will be <code>L * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>L * M * v</code>, the transformation of <code>this</code> matrix will be applied first!
mulLocalAffine Matrix4d mulLocalAffine(Matrix4d left, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulLocalAffine Matrix4d mulLocalAffine(Matrix4d left): Pre-multiply this matrix by the supplied <code>left</code> matrix, both of which are assumed to be {@link #isAffine() affine}, and store the result in <code>this</code>. <p> This method assumes that <code>this</code> matrix and the given <code>left</code> matrix both represent an {@link #isAffine() affine} transformation (i.e. their last rows are equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrices only represent affine transformations, such as translation, rotation, scaling and shearing (in any combination). <p> This method will not modify either the last row of <code>this</code> or the last row of <code>left</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the <code>left</code> matrix, then the new matrix will be <code>L * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>L * M * v</code>, the transformation of <code>this</code> matrix will be applied first!
mulOrthoAffine Matrix4d mulOrthoAffine(Matrix4d view, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulOrthoAffine Matrix4d mulOrthoAffine(Matrix4d view): Multiply <code>this</code> orthographic projection matrix by the supplied {@link #isAffine() affine} <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!
mulPerspectiveAffine Matrix4d mulPerspectiveAffine(Matrix4d view, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulPerspectiveAffine Matrix4d mulPerspectiveAffine(Matrix4d view): Multiply <code>this</code> symmetric perspective projection matrix by the supplied {@link #isAffine() affine} <code>view</code> matrix. <p> If <code>P</code> is <code>this</code> matrix and <code>V</code> the <code>view</code> matrix, then the new matrix will be <code>P * V</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>P * V * v</code>, the transformation of the <code>view</code> matrix will be applied first!
mulPerspectiveAffine Matrix4d mulPerspectiveAffine(Matrix4x3d view, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
mulTranslationAffine Matrix4d mulTranslationAffine(Matrix4d right, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
negateX Matrix4d negateX(): Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 </pre>
negateX Matrix4d negateX(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
negateY Matrix4d negateY(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 -1 0 0 0 0 1 0 0 0 0 1 </pre>
negateY Matrix4d negateY(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
negateZ Matrix4d negateZ(): Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 1 0 0 0 0 -1 0 0 0 0 1 </pre>
negateZ Matrix4d negateZ(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
normal Matrix3d normal(Matrix3d dest): Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code> and store it into <code>dest</code>. <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 Matrix3d#set(Matrix4d)} to set a given Matrix3d to only the upper left 3x3 submatrix of this matrix.
normal Matrix4d normal(Matrix4d dest): Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code> and store it into the upper 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(Matrix4d)} to set a given Matrix4d to only the upper left 3x3 submatrix of a given matrix.
normal Matrix4d normal(): Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code> and store it into the upper 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(Matrix4d)} to set a given Matrix4f to only the upper left 3x3 submatrix of this matrix.
normalize3x3 Matrix3d normalize3x3(Matrix3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
normalize3x3 Matrix4d normalize3x3(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
normalize3x3 Matrix4d normalize3x3(): Normalize the upper 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>).
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 Matrix4d obliqueZ(double a, double b, Matrix4d 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 0 0 0 1 </pre>
obliqueZ Matrix4d 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 0 0 0 1 </pre>
origin Vector3d origin(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
originAffine Vector3d originAffine(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
ortho Matrix4d 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>
ortho Matrix4d 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 Matrix4d ortho(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d 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 Matrix4d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d 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>
ortho2D Matrix4d 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>
ortho2D Matrix4d ortho2D(double left, double right, double bottom, double top, Matrix4d 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, Matrix4d) 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>
ortho2DLH Matrix4d 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>
ortho2DLH Matrix4d ortho2DLH(double left, double right, double bottom, double top, Matrix4d 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, Matrix4d) 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>
orthoCrop Matrix4d orthoCrop(Matrix4d view, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
orthoLH Matrix4d 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>
orthoLH Matrix4d 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 Matrix4d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d 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 Matrix4d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d 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>
orthoSymmetric Matrix4d 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>
orthoSymmetric Matrix4d 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 Matrix4d orthoSymmetric(double width, double height, double zNear, double zFar, Matrix4d 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, Matrix4d) 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 Matrix4d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4d 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, Matrix4d) 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>
orthoSymmetricLH Matrix4d 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>
orthoSymmetricLH Matrix4d 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 Matrix4d orthoSymmetricLH(double width, double height, double zNear, double zFar, Matrix4d 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, Matrix4d) 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 Matrix4d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4d 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, Matrix4d) 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>
perspective Matrix4d perspective(double fovy, double aspect, double zNear, double zFar): Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double) setPerspective}.
perspective Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne): Apply a symmetric perspective projection frustum transformation using 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double, bool) setPerspective}.
perspective Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, Matrix4d dest): Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double) setPerspective}.
perspective Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double, bool) setPerspective}.
perspectiveFar double perspectiveFar(): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveFov double perspectiveFov(): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveFrustumSlice Matrix4d perspectiveFrustumSlice(double near, double far, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveInvOrigin Vector3d perspectiveInvOrigin(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveLH Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar): Apply a symmetric perspective projection frustum transformation for a left-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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double) setPerspectiveLH}.
perspectiveLH Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, Matrix4d dest): Apply a symmetric perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double) setPerspectiveLH}.
perspectiveLH Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne): Apply a symmetric perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double, bool) setPerspectiveLH}.
perspectiveLH Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Apply a symmetric perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double, bool) setPerspectiveLH}.
perspectiveNear double perspectiveNear(): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenter Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar): Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double) setPerspectiveOffCenter}.
perspectiveOffCenter Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne): Apply an asymmetric off-center perspective projection frustum transformation using for a right-handed coordinate system using the given NDC z range to this matrix. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double, bool) setPerspectiveOffCenter}.
perspectiveOffCenter Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, Matrix4d dest): Apply an asymmetric off-center perspective projection frustum 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> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double) setPerspectiveOffCenter}.
perspectiveOffCenter Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Apply an asymmetric off-center perspective projection frustum 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> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double, bool) setPerspectiveOffCenter}.
perspectiveOffCenterFov Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFov Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar): Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFov(double, double, double, double, double, double) setPerspectiveOffCenterFov}.
perspectiveOffCenterFov Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFov Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne): Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFov(double, double, double, double, double, double, bool) setPerspectiveOffCenterFov}.
perspectiveOffCenterFovLH Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFovLH Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar): Apply an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFovLH(double, double, double, double, double, double) setPerspectiveOffCenterFovLH}.
perspectiveOffCenterFovLH Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFovLH Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne): Apply an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFovLH(double, double, double, double, double, double, bool) setPerspectiveOffCenterFovLH}.
perspectiveOrigin Vector3d perspectiveOrigin(Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveRect Matrix4d perspectiveRect(double width, double height, double zNear, double zFar): Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double) setPerspectiveRect}.
perspectiveRect Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne): Apply a symmetric perspective projection frustum transformation using 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double, bool) setPerspectiveRect}.
perspectiveRect Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, Matrix4d dest): Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double) setPerspectiveRect}.
perspectiveRect Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4d dest): Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double, bool) setPerspectiveRect}.
pick Matrix4d 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.
pick Matrix4d pick(double x, double y, double width, double height, int[] viewport, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
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.
project Vector4d project(Vector3d position, int[] viewport, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
project Vector3d project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest): Undocumented in source. Be warned that the author may not have intended to support it.
project Vector3d project(Vector3d position, int[] viewport, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
project Vector4d project(double x, double y, double z, int[] viewport, Vector4d winCoordsDest): Undocumented in source. Be warned that the author may not have intended to support it.
projectedGridRange Matrix4d projectedGridRange(Matrix4d projector, double sLower, double sUpper, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4d reflect(Vector3d normal, Vector3d point, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4d reflect(Quaterniond orientation, Vector3d point, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4d 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 Matrix4d 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 Matrix4d reflect(double nx, double ny, double nz, double px, double py, double pz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflect Matrix4d 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 Matrix4d 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 Matrix4d reflect(double a, double b, double c, double d, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
reflection Matrix4d 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>.
reflection Matrix4d 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 Matrix4d 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 Matrix4d 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>
rotate Matrix4d rotate(double ang, double x, double y, double z, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotate Matrix4d 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 Matrix4d 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 Matrix4d rotate(Quaterniond quat, Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotate Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotate Matrix4d rotate(double angle, Vector3d axis, Matrix4d 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 Matrix4d rotate(AxisAngle4d axisAngle, Matrix4d 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(ref AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotate Matrix4d 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(ref AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotateAffine Matrix4d rotateAffine(Quaterniond quat, Matrix4d dest): Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this {@link #isAffine() affine} matrix and store the result in <code>dest</code>. <p> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateAffine Matrix4d rotateAffine(Quaterniond quat): Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix. <p> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateAffine Matrix4d rotateAffine(double ang, double x, double y, double z, Matrix4d dest): Apply rotation to this {@link #isAffine() affine} 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> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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>
rotateAffine Matrix4d rotateAffine(double ang, double x, double y, double z): Apply rotation to this {@link #isAffine() affine} matrix by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis. <p> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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>
rotateAffineXYZ Matrix4d rotateAffineXYZ(double angleX, double angleY, double angleZ, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateAffineXYZ Matrix4d rotateAffineXYZ(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> This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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>
rotateAffineYXZ Matrix4d rotateAffineYXZ(double angleY, double angleX, double angleZ, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateAffineYXZ Matrix4d rotateAffineYXZ(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> This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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!
rotateAffineZYX Matrix4d rotateAffineZYX(double angleZ, double angleY, double angleX, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateAffineZYX Matrix4d rotateAffineZYX(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> This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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!
rotateAround Matrix4d 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>
rotateAround Matrix4d rotateAround(Quaterniond quat, double ox, double oy, double oz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateAroundAffine Matrix4d rotateAroundAffine(Quaterniond quat, double ox, double oy, double oz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateAroundLocal Matrix4d rotateAroundLocal(Quaterniond quat, double ox, double oy, double oz): Pre-multiply the rotation - and possibly scaling - 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>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> This method is equivalent to calling: <code>translateLocal(-ox, -oy, -oz).rotateLocal(quat).translateLocal(ox, oy, oz)</code> <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateAroundLocal Matrix4d rotateAroundLocal(Quaterniond quat, double ox, double oy, double oz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateLocal Matrix4d rotateLocal(Quaterniond quat, Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateLocal Matrix4d rotateLocal(Quaterniond quat): Pre-multiply 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>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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateLocal Matrix4d 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 Matrix4d rotateLocal(double ang, double x, double y, double z, Matrix4d 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 Matrix4d 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 Matrix4d rotateLocalX(double ang, Matrix4d 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 Matrix4d 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 Matrix4d rotateLocalY(double ang, Matrix4d 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 Matrix4d 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 Matrix4d rotateLocalZ(double ang, Matrix4d 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 Matrix4d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4d 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(double, double, double, double, double, double) rotationTowards()}. <p> This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine(), dest)</code>
rotateTowards Matrix4d 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>mulAffine(new Matrix4d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine())</code>
rotateTowards Matrix4d rotateTowards(Vector3d direction, 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>direction</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(ref Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invertAffine())</code>
rotateTowards Matrix4d rotateTowards(Vector3d direction, Vector3d up, Matrix4d dest): Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>direction</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(ref Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invertAffine(), dest)</code>
rotateTowardsXY Matrix4d rotateTowardsXY(double dirX, double dirY, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateTowardsXY Matrix4d rotateTowardsXY(double dirX, double dirY): Apply rotation about the Z axis to align the local <code>+X</code> towards <code>(dirX, dirY)</code>. <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> The vector <code>(dirX, dirY)</code> must be a unit vector.
rotateTranslation Matrix4d rotateTranslation(Quaterniond quat, Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotateTranslation Matrix4d rotateTranslation(double ang, double x, double y, double z, Matrix4d 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 Matrix4d 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 Matrix4d rotateX(double ang, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ Matrix4d rotateXYZ(double angleX, double angleY, double angleZ, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ Matrix4d 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 Matrix4d 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 Matrix4d 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 Matrix4d rotateY(double ang, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateYXZ Matrix4d rotateYXZ(double angleY, double angleX, double angleZ, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateYXZ Matrix4d 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 Matrix4d 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>
rotateZ Matrix4d 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 Matrix4d rotateZ(double ang, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateZYX Matrix4d rotateZYX(double angleZ, double angleY, double angleX, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
rotateZYX Matrix4d 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 Matrix4d 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>
rotation Matrix4d 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>
rotation Matrix4d 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 Matrix4d 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(ref Quaterniond) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
rotation Matrix4d 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(ref AxisAngle4d) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
rotationAround Matrix4d 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 Matrix4d 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>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(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine()</code>
rotationTowards Matrix4d 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).invertAffine()</code>
rotationTowardsXY Matrix4d rotationTowardsXY(double dirX, double dirY): Set this matrix to a rotation transformation about the Z axis to align the local <code>+X</code> towards <code>(dirX, dirY)</code>. <p> The vector <code>(dirX, dirY)</code> must be a unit vector.
rotationX Matrix4d 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 Matrix4d 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 Matrix4d 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 Matrix4d 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 Matrix4d 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 Matrix4d 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 Matrix4d scale(Vector3d xyz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scale Matrix4d 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 Matrix4d scale(double x, double y, double z, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scale Matrix4d 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 Matrix4d scale(double xyz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scale Matrix4d 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!
scaleAround Matrix4d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleAround Matrix4d 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 Matrix4d 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 Matrix4d scaleAround(double factor, double ox, double oy, double oz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleAroundLocal Matrix4d scaleAroundLocal(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleAroundLocal Matrix4d scaleAroundLocal(double sx, double sy, double sz, double ox, double oy, double oz): Pre-multiply 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>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! <p> This method is equivalent to calling: <code>new Matrix4d().translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz).mul(this, this)</code>
scaleAroundLocal Matrix4d scaleAroundLocal(double factor, double ox, double oy, double oz): Pre-multiply 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>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! <p> This method is equivalent to calling: <code>new Matrix4d().translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz).mul(this, this)</code>
scaleAroundLocal Matrix4d scaleAroundLocal(double factor, double ox, double oy, double oz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal Matrix4d scaleLocal(double x, double y, double z, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal Matrix4d scaleLocal(double xyz, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal Matrix4d scaleLocal(double xyz): Pre-multiply scaling to this matrix by scaling the 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>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 Matrix4d 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!
scaleXY Matrix4d scaleXY(double x, double y, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
scaleXY Matrix4d 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!
scaling Matrix4d 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.
scaling Matrix4d scaling(double x, double y, double z): Set this matrix to be a simple scale matrix.
scaling Matrix4d 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(ref Vector3d) scale()} instead.
set Matrix4d set(Matrix3d mat): Set the upper left 3x3 submatrix of this {@link Matrix4d} to the given {@link Matrix3d} and the rest to identity.
set Matrix4d set(AxisAngle4d axisAngle): Set this matrix to be equivalent to the rotation specified by the given {@link AxisAngle4d}.
set Matrix4d 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> <p> Reference: <a href="http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToMatrix/">http://www.euclideanspace.com/</a>
set Matrix4d set(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33): Set the values within this matrix to the supplied double values. The matrix will look like this:<br><br>
set Matrix4d 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 Matrix4d 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 Matrix4d set(Vector4d col0, Vector4d col1, Vector4d col2, Vector4d col3): Set the four columns of this matrix to the supplied vectors, respectively.
set Matrix4d set(Matrix4d m): Store the values of the given matrix <code>m</code> into <code>this</code> matrix.
set Matrix4d set(Matrix4x3d m): Store the values of the given matrix <code>m</code> into <code>this</code> matrix and set the other matrix elements to identity.
set Matrix4d set(int column, int row, double value): Set the matrix element at the given column and row to the specified value.
set3x3 Matrix4d set3x3(Matrix4d mat): Set the upper left 3x3 submatrix of this {@link Matrix4d} to that of the given {@link Matrix4d} and don't change the other elements.
set3x3 Matrix4d set3x3(Matrix3d mat): Set the upper left 3x3 submatrix of this {@link Matrix4d} to the given {@link Matrix3d} and don't change the other elements.
set4x3 Matrix4d set4x3(Matrix4x3d mat): Set the upper 4x3 submatrix of this {@link Matrix4d} to the given {@link Matrix4x3d} and don't change the other elements.
set4x3 Matrix4d set4x3(Matrix4d mat): Set the upper 4x3 submatrix of this {@link Matrix4d} to the upper 4x3 submatrix of the given {@link Matrix4d} and don't change the other elements.
setColumn Matrix4d setColumn(int column, Vector4d src): Set the column at the given <code>column</code> index, starting with <code>0</code>.
setFromIntrinsic Matrix4d setFromIntrinsic(double alphaX, double alphaY, double gamma, double u0, double v0, int imgWidth, int imgHeight, double near, double far): Set this matrix to represent a perspective projection equivalent to the given intrinsic camera calibration parameters. The resulting matrix will be suited for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> See: <a href="https://en.wikipedia.org/wiki/Camera_resectioning#Intrinsic_parameters">https://en.wikipedia.org/</a> <p> Reference: <a href="http://ksimek.github.io/2013/06/03/calibrated_cameras_in_opengl/">http://ksimek.github.io/</a>
setFrustum Matrix4d setFrustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Set this matrix to be an arbitrary perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> In order to apply the perspective frustum transformation to an existing transformation, use {@link #frustum(double, double, double, double, double, double, bool) frustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
setFrustum Matrix4d setFrustum(double left, double right, double bottom, double top, double zNear, double zFar): Set this matrix to be an arbitrary perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective frustum transformation to an existing transformation, use {@link #frustum(double, double, double, double, double, double) frustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
setFrustumLH Matrix4d setFrustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne): Set this matrix to be an arbitrary perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective frustum transformation to an existing transformation, use {@link #frustumLH(double, double, double, double, double, double, bool) frustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
setFrustumLH Matrix4d setFrustumLH(double left, double right, double bottom, double top, double zNear, double zFar): Set this matrix to be an arbitrary perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective frustum transformation to an existing transformation, use {@link #frustumLH(double, double, double, double, double, double) frustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
setLookAlong Matrix4d 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(ref 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(ref Vector3d, Vector3d)}.
setLookAlong Matrix4d 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()}
setLookAt Matrix4d 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(ref Vector3d, Vector3d, Vector3d) lookAt()}.
setLookAt Matrix4d 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}.
setLookAtLH Matrix4d 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(ref Vector3d, Vector3d, Vector3d) lookAt()}.
setLookAtLH Matrix4d 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}.
setOrtho Matrix4d 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>
setOrtho Matrix4d 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>
setOrtho2D Matrix4d 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 Matrix4d 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 Matrix4d 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>
setOrthoLH Matrix4d 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>
setOrthoSymmetric Matrix4d 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>
setOrthoSymmetric Matrix4d 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>
setOrthoSymmetricLH Matrix4d 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>
setOrthoSymmetricLH Matrix4d 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>
setPerspective Matrix4d setPerspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne): Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspective(double, double, double, double, bool) perspective()}.
setPerspective Matrix4d setPerspective(double fovy, double aspect, double zNear, double zFar): Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspective(double, double, double, double) perspective()}.
setPerspectiveLH Matrix4d setPerspectiveLH(double fovy, double aspect, double zNear, double zFar): Set this matrix to be a symmetric perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveLH(double, double, double, double) perspectiveLH()}.
setPerspectiveLH Matrix4d setPerspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne): Set this matrix to be a symmetric perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveLH(double, double, double, double, bool) perspectiveLH()}.
setPerspectiveOffCenter Matrix4d setPerspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne): Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenter(double, double, double, double, double, double) perspectiveOffCenter()}.
setPerspectiveOffCenter Matrix4d setPerspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar): Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenter(double, double, double, double, double, double) perspectiveOffCenter()}.
setPerspectiveOffCenterFov Matrix4d setPerspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne): Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFov(double, double, double, double, double, double, bool) perspectiveOffCenterFov()}.
setPerspectiveOffCenterFov Matrix4d setPerspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar): Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFov(double, double, double, double, double, double) perspectiveOffCenterFov()}.
setPerspectiveOffCenterFovLH Matrix4d setPerspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne): Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFovLH(double, double, double, double, double, double, bool) perspectiveOffCenterFovLH()}.
setPerspectiveOffCenterFovLH Matrix4d setPerspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar): Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFovLH(double, double, double, double, double, double) perspectiveOffCenterFovLH()}.
setPerspectiveRect Matrix4d setPerspectiveRect(double width, double height, double zNear, double zFar): Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveRect(double, double, double, double) perspectiveRect()}.
setPerspectiveRect Matrix4d setPerspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne): Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveRect(double, double, double, double, bool) perspectiveRect()}.
setRotationXYZ Matrix4d setRotationXYZ(double angleX, double angleY, double angleZ): Set only the upper 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 Matrix4d setRotationYXZ(double angleY, double angleX, double angleZ): Set only the upper 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 Matrix4d setRotationZYX(double angleZ, double angleY, double angleX): Set only the upper 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 Matrix4d setRow(int row, Vector4d src): Set the row at the given <code>row</code> index, starting with <code>0</code>.
setRowColumn Matrix4d setRowColumn(int row, int column, double value): Set the matrix element at the given row and column to the specified value.
setTranslation Matrix4d 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(ref Vector3d)}. To apply a translation, use {@link #translate(ref Vector3d)}.
setTranslation Matrix4d 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)}.
setTransposed Matrix4d setTransposed(Matrix4d m): Store the values of the transpose of the given matrix <code>m</code> into <code>this</code> matrix.
setm00 Matrix4d setm00(double m00): Set the value of the matrix element at column 0 and row 0.
setm01 Matrix4d setm01(double m01): Set the value of the matrix element at column 0 and row 1.
setm02 Matrix4d setm02(double m02): Set the value of the matrix element at column 0 and row 2.
setm03 Matrix4d setm03(double m03): Set the value of the matrix element at column 0 and row 3.
setm10 Matrix4d setm10(double m10): Set the value of the matrix element at column 1 and row 0.
setm11 Matrix4d setm11(double m11): Set the value of the matrix element at column 1 and row 1.
setm12 Matrix4d setm12(double m12): Set the value of the matrix element at column 1 and row 2.
setm13 Matrix4d setm13(double m13): Set the value of the matrix element at column 1 and row 3.
setm20 Matrix4d setm20(double m20): Set the value of the matrix element at column 2 and row 0.
setm21 Matrix4d setm21(double m21): Set the value of the matrix element at column 2 and row 1.
setm22 Matrix4d setm22(double m22): Set the value of the matrix element at column 2 and row 2.
setm23 Matrix4d setm23(double m23): Set the value of the matrix element at column 2 and row 3.
setm30 Matrix4d setm30(double m30): Set the value of the matrix element at column 3 and row 0.
setm31 Matrix4d setm31(double m31): Set the value of the matrix element at column 3 and row 1.
setm32 Matrix4d setm32(double m32): Set the value of the matrix element at column 3 and row 2.
setm33 Matrix4d setm33(double m33): Set the value of the matrix element at column 3 and row 3.
shadow Matrix4d shadow(Vector4d light, double a, double b, double c, double d, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4d 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>
shadow Matrix4d 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 Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4d shadow(Vector4d light, Matrix4d planeTransform, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4d shadow(Vector4d light, Matrix4d 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 Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4d planeTransform, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
shadow Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4d 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!
sub Matrix4d sub(Matrix4d subtrahend, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
sub Matrix4d sub(Matrix4d subtrahend): Component-wise subtract <code>subtrahend</code> from <code>this</code>.
sub4x3 Matrix4d sub4x3(Matrix4d subtrahend, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
sub4x3 Matrix4d sub4x3(Matrix4d subtrahend): Component-wise subtract the upper 4x3 submatrices of <code>subtrahend</code> from <code>this</code>.
swap Matrix4d swap(Matrix4d other): Exchange the values of <code>this</code> matrix with the given <code>other</code> matrix.
testAab bool testAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ): Undocumented in source. Be warned that the author may not have intended to support it.
testPoint bool testPoint(double x, double y, double z): Undocumented in source. Be warned that the author may not have intended to support it.
testSphere bool testSphere(double x, double y, double z, double r): Undocumented in source. Be warned that the author may not have intended to support it.
tile Matrix4d tile(int x, int y, int w, int h, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
tile Matrix4d tile(int x, int y, int w, int h): This method is equivalent to calling: <code>translate(w-1-2*x, h-1-2*y, 0).scale(w, h, 1)</code> <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the created transformation 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 created transformation will be applied first!
transform Vector4d transform(double x, double y, double z, double w, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
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 Matrix4d 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 Matrix4d transformAab(Vector3d min, Vector3d max, Vector3d outMin, Vector3d outMax): Undocumented in source. Be warned that the author may not have intended to support it.
transformAffine Vector4d transformAffine(double x, double y, double z, double w, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformAffine Vector4d transformAffine(Vector4d v, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformAffine Vector4d transformAffine(Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformDirection Vector3d transformDirection(double x, double y, double z, Vector3d dest): 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 dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformPosition Vector3d transformPosition(double x, double y, double z, Vector3d dest): 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 dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector3d transformProject(double x, double y, double z, double w, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector3d transformProject(Vector4d v, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector3d transformProject(double x, double y, double z, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector3d transformProject(Vector3d v, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector3d transformProject(Vector3d v): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector4d transformProject(double x, double y, double z, double w, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector4d transformProject(Vector4d v, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformProject Vector4d transformProject(Vector4d v): Undocumented in source. Be warned that the author may not have intended to support it.
transformTranspose Vector4d transformTranspose(double x, double y, double z, double w, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformTranspose Vector4d transformTranspose(Vector4d v, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transformTranspose Vector4d transformTranspose(Vector4d v): Undocumented in source. Be warned that the author may not have intended to support it.
translate Matrix4d 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 Matrix4d translate(double x, double y, double z, Matrix4d 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 Matrix4d translate(Vector3d offset, Matrix4d 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(ref Vector3d)}.
translate Matrix4d 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(ref Vector3d)}.
translateLocal Matrix4d 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 Matrix4d translateLocal(double x, double y, double z, Matrix4d 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 Matrix4d translateLocal(Vector3d offset, Matrix4d 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(ref Vector3d)}.
translateLocal Matrix4d 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(ref Vector3d)}.
translation Matrix4d 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 Matrix4d 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 Matrix4d 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 Matrix4d 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 - and possibly scaling - transformation specified by the given quaternion. <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 Matrix4d 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>
translationRotateInvert Matrix4d 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>
translationRotateScale Matrix4d 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>
translationRotateScale Matrix4d 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 Matrix4d translationRotateScale(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double scale): 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 all three 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(tx, ty, tz).rotate(quat).scale(scale)</code>
translationRotateScale Matrix4d translationRotateScale(Vector3d translation, Quaterniond quat, double 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 all three 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>
translationRotateScaleInvert Matrix4d translationRotateScaleInvert(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)<sup>-1</sup></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> This method is equivalent to calling: <code>translationRotateScale(...).invert()</code>
translationRotateScaleInvert Matrix4d translationRotateScaleInvert(Vector3d translation, Quaterniond quat, Vector3d scale): Set <code>this</code> matrix to <code>(T * R * S)<sup>-1</sup></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> This method is equivalent to calling: <code>translationRotateScale(...).invert()</code>
translationRotateScaleInvert Matrix4d translationRotateScaleInvert(Vector3d translation, Quaterniond quat, double scale): Set <code>this</code> matrix to <code>(T * R * S)<sup>-1</sup></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 all three axes by <code>scale</code>. <p> This method is equivalent to calling: <code>translationRotateScale(...).invert()</code>
translationRotateScaleMulAffine Matrix4d translationRotateScaleMulAffine(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz, Matrix4d 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 - and possibly scaling - 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> and <code>M</code> is an {@link #isAffine() affine} matrix. <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).mulAffine(m)</code>
translationRotateTowards Matrix4d 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 Matrix4d 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>
transpose Matrix4d transpose(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transpose Matrix4d transpose(): Transpose this matrix.
transpose3x3 Matrix3d transpose3x3(Matrix3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transpose3x3 Matrix4d transpose3x3(Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
transpose3x3 Matrix4d transpose3x3(): Transpose only the upper left 3x3 submatrix of this matrix. <p> All other matrix elements are left unchanged.
trapezoidCrop Matrix4d trapezoidCrop(double p0x, double p0y, double p1x, double p1y, double p2x, double p2y, double p3x, double p3y): Set <code>this</code> matrix to a perspective transformation that maps the trapezoid spanned by the four corner coordinates <code>(p0x, p0y)</code>, <code>(p1x, p1y)</code>, <code>(p2x, p2y)</code> and <code>(p3x, p3y)</code> to the unit square <code>[(-1, -1)..(+1, +1)]</code>. <p> The corner coordinates are given in counter-clockwise order starting from the <i>left</i> corner on the smaller parallel side of the trapezoid seen when looking at the trapezoid oriented with its shorter parallel edge at the bottom and its longer parallel edge at the top. <p> Reference: <a href="http://www.comp.nus.edu.sg/~tants/tsm/TSM_recipe.html">Trapezoidal Shadow Maps (TSM) - Recipe</a>
unproject Vector4d unproject(Vector3d winCoords, int[] viewport, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unproject Vector3d unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unproject Vector4d unproject(double winX, double winY, double winZ, int[] viewport, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unproject Vector3d unproject(Vector3d winCoords, int[] viewport, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv Vector3d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv Vector3d unprojectInv(Vector3d winCoords, int[] viewport, Vector3d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv Vector4d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv Vector4d unprojectInv(Vector3d winCoords, int[] viewport, Vector4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInvRay Matrix4d unprojectInvRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInvRay Matrix4d unprojectInvRay(Vector2d winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectRay Matrix4d unprojectRay(Vector2d winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest): Undocumented in source. Be warned that the author may not have intended to support it.
unprojectRay Matrix4d unprojectRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest): Undocumented in source. Be warned that the author may not have intended to support it.
withLookAtUp Matrix4d withLookAtUp(double upX, double upY, double upZ, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
withLookAtUp Matrix4d withLookAtUp(double upX, double upY, double upZ): Apply a transformation to this matrix to ensure that the local Y axis (as obtained by {@link #positiveY(ref Vector3d)}) will be coplanar to the plane spanned by the local Z axis (as obtained by {@link #positiveZ(ref Vector3d)}) and the given vector <code>(upX, upY, upZ)</code>. <p> This effectively ensures that the resulting matrix will be equal to the one obtained from {@link #setLookAt(double, double, double, double, double, double, double, double, double)} called with the current local origin of this matrix (as obtained by {@link #originAffine(ref Vector3d)}), the sum of this position and the negated local Z axis as well as the given vector <code>(upX, upY, upZ)</code>. <p> This method must only be called on {@link #isAffine()} matrices.
withLookAtUp Matrix4d withLookAtUp(Vector3d up, Matrix4d dest): Undocumented in source. Be warned that the author may not have intended to support it.
withLookAtUp Matrix4d withLookAtUp(Vector3d up): Apply a transformation to this matrix to ensure that the local Y axis (as obtained by {@link #positiveY(ref Vector3d)}) will be coplanar to the plane spanned by the local Z axis (as obtained by {@link #positiveZ(ref Vector3d)}) and the given vector <code>up</code>. <p> This effectively ensures that the resulting matrix will be equal to the one obtained from {@link #setLookAt(ref Vector3d, Vector3d, Vector3d)} called with the current local origin of this matrix (as obtained by {@link #originAffine(ref Vector3d)}), the sum of this position and the negated local Z axis as well as the given vector <code>up</code>. <p> This method must only be called on {@link #isAffine()} matrices.
zero Matrix4d zero(): Set all the values within this matrix to 0.

Static functions

projViewFromRectangle void projViewFromRectangle(Vector3d eye, Vector3d p, Vector3d x, Vector3d y, double nearFarDist, bool zeroToOne, Matrix4d projDest, Matrix4d viewDest): Create a view and projection matrix from a given <code>eye</code> position, a given bottom left corner position <code>p</code> of the near plane rectangle and the extents of the near plane rectangle along its local <code>x</code> and <code>y</code> axes, and store the resulting matrices in <code>projDest</code> and <code>viewDest</code>. <p> This method creates a view and perspective projection matrix assuming that there is a pinhole camera at position <code>eye</code> projecting the scene onto the near plane defined by the rectangle. <p> All positions and lengths are in the same (world) unit.

Static variables

CORNER_NXNYNZ int CORNER_NXNYNZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, -1, -1)</code> when using the identity matrix.
CORNER_NXNYPZ int CORNER_NXNYPZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, -1, 1)</code> when using the identity matrix.
CORNER_NXPYNZ int CORNER_NXPYNZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, 1, -1)</code> when using the identity matrix.
CORNER_NXPYPZ int CORNER_NXPYPZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, 1, 1)</code> when using the identity matrix.
CORNER_PXNYNZ int CORNER_PXNYNZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, -1, -1)</code> when using the identity matrix.
CORNER_PXNYPZ int CORNER_PXNYPZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, -1, 1)</code> when using the identity matrix.
CORNER_PXPYNZ int CORNER_PXPYNZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, 1, -1)</code> when using the identity matrix.
CORNER_PXPYPZ int CORNER_PXPYPZ;: Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, 1, 1)</code> when using the identity matrix.
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_AFFINE byte PROPERTY_AFFINE;: Bit returned by {@link #properties()} to indicate that the matrix represents an affine transformation.
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 upper-left 3x3 submatrix represents an orthogonal matrix (i.e. orthonormal basis). For practical reasons, this property also always implies {@link #PROPERTY_AFFINE} in this implementation.
PROPERTY_PERSPECTIVE byte PROPERTY_PERSPECTIVE;: Bit returned by {@link #properties()} to indicate that the matrix represents a perspective transformation.
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.
m03 double m03;: Undocumented in source.
m10 double m10;: Undocumented in source.
m11 double m11;: Undocumented in source.
m12 double m12;: Undocumented in source.
m13 double m13;: Undocumented in source.
m20 double m20;: Undocumented in source.
m21 double m21;: Undocumented in source.
m22 double m22;: Undocumented in source.
m23 double m23;: Undocumented in source.
m30 double m30;: Undocumented in source.
m31 double m31;: Undocumented in source.
m32 double m32;: Undocumented in source.
m33 double m33;: Undocumented in source.
properties int properties;: Undocumented in source.

Meta

Source

See Implementation

doml matrix_4d structs

Matrix4d