All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.joml.Matrix4x3dc Maven / Gradle / Ivy

There is a newer version: 1.10.1
Show newest version
/*
 * The MIT License
 *
 * Copyright (c) 2016-2020 JOML
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package org.joml;

import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.util.*;

/**
 * Interface to a read-only view of a 4x3 matrix of double-precision floats.
 * 
 * @author Kai Burjack
 */
public interface Matrix4x3dc {

    /**
     * Argument to the first parameter of {@link #frustumPlane(int, Planed)}
     * identifying the plane with equation x=-1 when using the identity matrix.  
     */
    int PLANE_NX = 0;
    /**
     * Argument to the first parameter of {@link #frustumPlane(int, Planed)}
     * identifying the plane with equation x=1 when using the identity matrix.  
     */
    int PLANE_PX = 1;
    /**
     * Argument to the first parameter of {@link #frustumPlane(int, Planed)}
     * identifying the plane with equation y=-1 when using the identity matrix.  
     */
    int PLANE_NY = 2;
    /**
     * Argument to the first parameter of {@link #frustumPlane(int, Planed)}
     * identifying the plane with equation y=1 when using the identity matrix.  
     */
    int PLANE_PY = 3;
    /**
     * Argument to the first parameter of {@link #frustumPlane(int, Planed)}
     * identifying the plane with equation z=-1 when using the identity matrix.  
     */
    int PLANE_NZ = 4;
    /**
     * Argument to the first parameter of {@link #frustumPlane(int, Planed)}
     * identifying the plane with equation z=1 when using the identity matrix.  
     */
    int PLANE_PZ = 5;

    /**
     * Bit returned by {@link #properties()} to indicate that the matrix represents the identity transformation.
     */
    byte PROPERTY_IDENTITY = 1<<2;
    /**
     * Bit returned by {@link #properties()} to indicate that the matrix represents a pure translation transformation.
     */
    byte PROPERTY_TRANSLATION = 1<<3;
    /**
     * Bit returned by {@link #properties()} to indicate that the left 3x3 submatrix represents an orthogonal
     * matrix (i.e. orthonormal basis).
     */
    byte PROPERTY_ORTHONORMAL = 1<<4;

    /**
     * @return the properties of the matrix
     */
    int properties();

    /**
     * Return the value of the matrix element at column 0 and row 0.
     * 
     * @return the value of the matrix element
     */
    double m00();

    /**
     * Return the value of the matrix element at column 0 and row 1.
     * 
     * @return the value of the matrix element
     */
    double m01();

    /**
     * Return the value of the matrix element at column 0 and row 2.
     * 
     * @return the value of the matrix element
     */
    double m02();

    /**
     * Return the value of the matrix element at column 1 and row 0.
     * 
     * @return the value of the matrix element
     */
    double m10();

    /**
     * Return the value of the matrix element at column 1 and row 1.
     * 
     * @return the value of the matrix element
     */
    double m11();

    /**
     * Return the value of the matrix element at column 1 and row 2.
     * 
     * @return the value of the matrix element
     */
    double m12();

    /**
     * Return the value of the matrix element at column 2 and row 0.
     * 
     * @return the value of the matrix element
     */
    double m20();

    /**
     * Return the value of the matrix element at column 2 and row 1.
     * 
     * @return the value of the matrix element
     */
    double m21();

    /**
     * Return the value of the matrix element at column 2 and row 2.
     * 
     * @return the value of the matrix element
     */
    double m22();

    /**
     * Return the value of the matrix element at column 3 and row 0.
     * 
     * @return the value of the matrix element
     */
    double m30();

    /**
     * Return the value of the matrix element at column 3 and row 1.
     * 
     * @return the value of the matrix element
     */
    double m31();

    /**
     * Return the value of the matrix element at column 3 and row 2.
     * 
     * @return the value of the matrix element
     */
    double m32();

    /**
     * Get the current values of this matrix and store them into the upper 4x3 submatrix of dest.
     * 

* The other elements of dest will not be modified. * * @see Matrix4d#set4x3(Matrix4x3dc) * * @param dest * the destination matrix * @return dest */ Matrix4d get(Matrix4d dest); /** * Multiply this matrix by the supplied right matrix and store the result in dest. *

* If M is this matrix and R the right matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * transformation of the right matrix will be applied first! * * @param right * the right operand of the multiplication * @param dest * will hold the result * @return dest */ Matrix4x3d mul(Matrix4x3dc right, Matrix4x3d dest); /** * Multiply this matrix by the supplied right matrix and store the result in dest. *

* If M is this matrix and R the right matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * transformation of the right matrix will be applied first! * * @param right * the right operand of the multiplication * @param dest * will hold the result * @return dest */ Matrix4x3d mul(Matrix4x3fc right, Matrix4x3d dest); /** * Multiply this matrix, which is assumed to only contain a translation, by the supplied right matrix and store the result in dest. *

* This method assumes that this matrix only contains a translation. *

* This method will not modify either the last row of this or the last row of right. *

* If M is this matrix and R the right matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * transformation of the right matrix will be applied first! * * @param right * the right operand of the matrix multiplication * @param dest * the destination matrix, which will hold the result * @return dest */ Matrix4x3d mulTranslation(Matrix4x3dc right, Matrix4x3d dest); /** * Multiply this matrix, which is assumed to only contain a translation, by the supplied right matrix and store the result in dest. *

* This method assumes that this matrix only contains a translation. *

* This method will not modify either the last row of this or the last row of right. *

* If M is this matrix and R the right matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * transformation of the right matrix will be applied first! * * @param right * the right operand of the matrix multiplication * @param dest * the destination matrix, which will hold the result * @return dest */ Matrix4x3d mulTranslation(Matrix4x3fc right, Matrix4x3d dest); /** * Multiply this orthographic projection matrix by the supplied view matrix * and store the result in dest. *

* If M is this matrix and V the view matrix, * then the new matrix will be M * V. So when transforming a * vector v with the new matrix by using M * V * v, the * transformation of the view matrix will be applied first! * * @param view * the matrix which to multiply this with * @param dest * the destination matrix, which will hold the result * @return dest */ Matrix4x3d mulOrtho(Matrix4x3dc view, Matrix4x3d dest); /** * Component-wise add this and other * by first multiplying each component of other by otherFactor, * adding that to this and storing the final result in dest. *

* The other components of dest will be set to the ones of this. *

* The matrices this and other will not be changed. * * @param other * the other matrix * @param otherFactor * the factor to multiply each of the other matrix's components * @param dest * will hold the result * @return dest */ Matrix4x3d fma(Matrix4x3dc other, double otherFactor, Matrix4x3d dest); /** * Component-wise add this and other * by first multiplying each component of other by otherFactor, * adding that to this and storing the final result in dest. *

* The other components of dest will be set to the ones of this. *

* The matrices this and other will not be changed. * * @param other * the other matrix * @param otherFactor * the factor to multiply each of the other matrix's components * @param dest * will hold the result * @return dest */ Matrix4x3d fma(Matrix4x3fc other, double otherFactor, Matrix4x3d dest); /** * Component-wise add this and other and store the result in dest. * * @param other * the other addend * @param dest * will hold the result * @return dest */ Matrix4x3d add(Matrix4x3dc other, Matrix4x3d dest); /** * Component-wise add this and other and store the result in dest. * * @param other * the other addend * @param dest * will hold the result * @return dest */ Matrix4x3d add(Matrix4x3fc other, Matrix4x3d dest); /** * Component-wise subtract subtrahend from this and store the result in dest. * * @param subtrahend * the subtrahend * @param dest * will hold the result * @return dest */ Matrix4x3d sub(Matrix4x3dc subtrahend, Matrix4x3d dest); /** * Component-wise subtract subtrahend from this and store the result in dest. * * @param subtrahend * the subtrahend * @param dest * will hold the result * @return dest */ Matrix4x3d sub(Matrix4x3fc subtrahend, Matrix4x3d dest); /** * Component-wise multiply this by other and store the result in dest. * * @param other * the other matrix * @param dest * will hold the result * @return dest */ Matrix4x3d mulComponentWise(Matrix4x3dc other, Matrix4x3d dest); /** * Return the determinant of this matrix. * * @return the determinant */ double determinant(); /** * Invert this matrix and store the result in dest. * * @param dest * will hold the result * @return dest */ Matrix4x3d invert(Matrix4x3d dest); /** * Invert this orthographic projection matrix and store the result into the given dest. *

* This method can be used to quickly obtain the inverse of an orthographic projection matrix. * * @param dest * will hold the inverse of this * @return dest */ Matrix4x3d invertOrtho(Matrix4x3d dest); /** * Transpose only the left 3x3 submatrix of this matrix and store the result in dest. *

* All other matrix elements are left unchanged. * * @param dest * will hold the result * @return dest */ Matrix4x3d transpose3x3(Matrix4x3d dest); /** * Transpose only the left 3x3 submatrix of this matrix and store the result in dest. * * @param dest * will hold the result * @return dest */ Matrix3d transpose3x3(Matrix3d dest); /** * Get only the translation components (m30, m31, m32) of this matrix and store them in the given vector xyz. * * @param dest * will hold the translation components of this matrix * @return dest */ Vector3d getTranslation(Vector3d dest); /** * Get the scaling factors of this matrix for the three base axes. * * @param dest * will hold the scaling factors for x, y and z * @return dest */ Vector3d getScale(Vector3d dest); /** * Get the current values of this matrix and store them into * dest. * * @param dest * the destination matrix * @return the passed in destination */ Matrix4x3d get(Matrix4x3d dest); /** * Get the current values of this matrix and store the represented rotation * into the given {@link Quaternionf}. *

* This method assumes that the first three column vectors of the left 3x3 submatrix are not normalized and * thus allows to ignore any additional scaling factor that is applied to the matrix. * * @see Quaternionf#setFromUnnormalized(Matrix4x3dc) * * @param dest * the destination {@link Quaternionf} * @return the passed in destination */ Quaternionf getUnnormalizedRotation(Quaternionf dest); /** * Get the current values of this matrix and store the represented rotation * into the given {@link Quaternionf}. *

* This method assumes that the first three column vectors of the left 3x3 submatrix are normalized. * * @see Quaternionf#setFromNormalized(Matrix4x3dc) * * @param dest * the destination {@link Quaternionf} * @return the passed in destination */ Quaternionf getNormalizedRotation(Quaternionf dest); /** * Get the current values of this matrix and store the represented rotation * into the given {@link Quaterniond}. *

* This method assumes that the first three column vectors of the left 3x3 submatrix are not normalized and * thus allows to ignore any additional scaling factor that is applied to the matrix. * * @see Quaterniond#setFromUnnormalized(Matrix4x3dc) * * @param dest * the destination {@link Quaterniond} * @return the passed in destination */ Quaterniond getUnnormalizedRotation(Quaterniond dest); /** * Get the current values of this matrix and store the represented rotation * into the given {@link Quaterniond}. *

* This method assumes that the first three column vectors of the left 3x3 submatrix are normalized. * * @see Quaterniond#setFromNormalized(Matrix4x3dc) * * @param dest * the destination {@link Quaterniond} * @return the passed in destination */ Quaterniond getNormalizedRotation(Quaterniond dest); /** * Store this matrix in column-major order into the supplied {@link DoubleBuffer} at the current * buffer {@link DoubleBuffer#position() position}. *

* This method will not increment the position of the given DoubleBuffer. *

* In order to specify the offset into the DoubleBuffer at which * the matrix is stored, use {@link #get(int, DoubleBuffer)}, taking * the absolute position as parameter. * * @see #get(int, DoubleBuffer) * * @param buffer * will receive the values of this matrix in column-major order at its current position * @return the passed in buffer */ DoubleBuffer get(DoubleBuffer buffer); /** * Store this matrix in column-major order into the supplied {@link DoubleBuffer} starting at the specified * absolute buffer position/index. *

* This method will not increment the position of the given {@link DoubleBuffer}. * * @param index * the absolute position into the {@link DoubleBuffer} * @param buffer * will receive the values of this matrix in column-major order * @return the passed in buffer */ DoubleBuffer get(int index, DoubleBuffer buffer); /** * Store this matrix in column-major order into the supplied {@link FloatBuffer} at the current * buffer {@link FloatBuffer#position() position}. *

* This method will not increment the position of the given * FloatBuffer. *

* In order to specify the offset into the FloatBuffer at which * the matrix is stored, use {@link #get(int, FloatBuffer)}, taking * the absolute position as parameter. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given FloatBuffer. * * @see #get(int, FloatBuffer) * * @param buffer * will receive the values of this matrix in column-major order at its current position * @return the passed in buffer */ FloatBuffer get(FloatBuffer buffer); /** * Store this matrix in column-major order into the supplied {@link FloatBuffer} starting at the specified * absolute buffer position/index. *

* This method will not increment the position of the given FloatBuffer. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given FloatBuffer. * * @param index * the absolute position into the FloatBuffer * @param buffer * will receive the values of this matrix in column-major order * @return the passed in buffer */ FloatBuffer get(int index, FloatBuffer buffer); /** * Store this matrix in column-major order into the supplied {@link ByteBuffer} at the current * buffer {@link ByteBuffer#position() position}. *

* This method will not increment the position of the given ByteBuffer. *

* In order to specify the offset into the ByteBuffer at which * the matrix is stored, use {@link #get(int, ByteBuffer)}, taking * the absolute position as parameter. * * @see #get(int, ByteBuffer) * * @param buffer * will receive the values of this matrix in column-major order at its current position * @return the passed in buffer */ ByteBuffer get(ByteBuffer buffer); /** * Store this matrix in column-major order into the supplied {@link ByteBuffer} starting at the specified * absolute buffer position/index. *

* This method will not increment the position of the given ByteBuffer. * * @param index * the absolute position into the ByteBuffer * @param buffer * will receive the values of this matrix in column-major order * @return the passed in buffer */ ByteBuffer get(int index, ByteBuffer buffer); /** * Store the elements of this matrix as float values in column-major order into the supplied {@link ByteBuffer} at the current * buffer {@link ByteBuffer#position() position}. *

* This method will not increment the position of the given ByteBuffer. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given ByteBuffer. *

* In order to specify the offset into the ByteBuffer at which * the matrix is stored, use {@link #getFloats(int, ByteBuffer)}, taking * the absolute position as parameter. * * @see #getFloats(int, ByteBuffer) * * @param buffer * will receive the elements of this matrix as float values in column-major order at its current position * @return the passed in buffer */ ByteBuffer getFloats(ByteBuffer buffer); /** * Store the elements of this matrix as float values in column-major order into the supplied {@link ByteBuffer} * starting at the specified absolute buffer position/index. *

* This method will not increment the position of the given ByteBuffer. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given ByteBuffer. * * @param index * the absolute position into the ByteBuffer * @param buffer * will receive the elements of this matrix as float values in column-major order * @return the passed in buffer */ ByteBuffer getFloats(int index, ByteBuffer buffer); /** * Store this matrix in column-major order at the given off-heap address. *

* This method will throw an {@link UnsupportedOperationException} when JOML is used with `-Djoml.nounsafe`. *

* This method is unsafe as it can result in a crash of the JVM process when the specified address range does not belong to this process. * * @param address * the off-heap address where to store this matrix * @return this */ Matrix4x3dc getToAddress(long address); /** * Store this matrix into the supplied double array in column-major order at the given offset. * * @param arr * the array to write the matrix values into * @param offset * the offset into the array * @return the passed in array */ double[] get(double[] arr, int offset); /** * Store this matrix into the supplied double array in column-major order. *

* In order to specify an explicit offset into the array, use the method {@link #get(double[], int)}. * * @see #get(double[], int) * * @param arr * the array to write the matrix values into * @return the passed in array */ double[] get(double[] arr); /** * Store the elements of this matrix as float values in column-major order into the supplied float array at the given offset. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given float array. * * @param arr * the array to write the matrix values into * @param offset * the offset into the array * @return the passed in array */ float[] get(float[] arr, int offset); /** * Store the elements of this matrix as float values in column-major order into the supplied float array. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given float array. *

* In order to specify an explicit offset into the array, use the method {@link #get(float[], int)}. * * @see #get(float[], int) * * @param arr * the array to write the matrix values into * @return the passed in array */ float[] get(float[] arr); /** * Store a 4x4 matrix in column-major order into the supplied array at the given offset, * where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). * * @param arr * the array to write the matrix values into * @param offset * the offset into the array * @return the passed in array */ double[] get4x4(double[] arr, int offset); /** * Store a 4x4 matrix in column-major order into the supplied array, * where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). *

* In order to specify an explicit offset into the array, use the method {@link #get4x4(double[], int)}. * * @see #get4x4(double[], int) * * @param arr * the array to write the matrix values into * @return the passed in array */ double[] get4x4(double[] arr); /** * Store a 4x4 matrix in column-major order into the supplied array at the given offset, * where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given float array. * * @param arr * the array to write the matrix values into * @param offset * the offset into the array * @return the passed in array */ float[] get4x4(float[] arr, int offset); /** * Store a 4x4 matrix in column-major order into the supplied array, * where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given float array. *

* In order to specify an explicit offset into the array, use the method {@link #get4x4(float[], int)}. * * @see #get4x4(float[], int) * * @param arr * the array to write the matrix values into * @return the passed in array */ float[] get4x4(float[] arr); /** * Store a 4x4 matrix in column-major order into the supplied {@link DoubleBuffer} at the current * buffer {@link DoubleBuffer#position() position}, where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). *

* This method will not increment the position of the given DoubleBuffer. *

* In order to specify the offset into the DoubleBuffer at which * the matrix is stored, use {@link #get4x4(int, DoubleBuffer)}, taking * the absolute position as parameter. * * @see #get4x4(int, DoubleBuffer) * * @param buffer * will receive the values of this matrix in column-major order at its current position * @return the passed in buffer */ DoubleBuffer get4x4(DoubleBuffer buffer); /** * Store a 4x4 matrix in column-major order into the supplied {@link DoubleBuffer} starting at the specified * absolute buffer position/index, where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). *

* This method will not increment the position of the given DoubleBuffer. * * @param index * the absolute position into the DoubleBuffer * @param buffer * will receive the values of this matrix in column-major order * @return the passed in buffer */ DoubleBuffer get4x4(int index, DoubleBuffer buffer); /** * Store a 4x4 matrix in column-major order into the supplied {@link ByteBuffer} at the current * buffer {@link ByteBuffer#position() position}, where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). *

* This method will not increment the position of the given ByteBuffer. *

* In order to specify the offset into the ByteBuffer at which * the matrix is stored, use {@link #get4x4(int, ByteBuffer)}, taking * the absolute position as parameter. * * @see #get4x4(int, ByteBuffer) * * @param buffer * will receive the values of this matrix in column-major order at its current position * @return the passed in buffer */ ByteBuffer get4x4(ByteBuffer buffer); /** * Store a 4x4 matrix in column-major order into the supplied {@link ByteBuffer} starting at the specified * absolute buffer position/index, where the upper 4x3 submatrix is this and the last row is (0, 0, 0, 1). *

* This method will not increment the position of the given ByteBuffer. * * @param index * the absolute position into the ByteBuffer * @param buffer * will receive the values of this matrix in column-major order * @return the passed in buffer */ ByteBuffer get4x4(int index, ByteBuffer buffer); /** * Store this matrix in row-major order into the supplied {@link DoubleBuffer} at the current * buffer {@link DoubleBuffer#position() position}. *

* This method will not increment the position of the given DoubleBuffer. *

* In order to specify the offset into the DoubleBuffer at which * the matrix is stored, use {@link #getTransposed(int, DoubleBuffer)}, taking * the absolute position as parameter. * * @see #getTransposed(int, DoubleBuffer) * * @param buffer * will receive the values of this matrix in row-major order at its current position * @return the passed in buffer */ DoubleBuffer getTransposed(DoubleBuffer buffer); /** * Store this matrix in row-major order into the supplied {@link DoubleBuffer} starting at the specified * absolute buffer position/index. *

* This method will not increment the position of the given DoubleBuffer. * * @param index * the absolute position into the DoubleBuffer * @param buffer * will receive the values of this matrix in row-major order * @return the passed in buffer */ DoubleBuffer getTransposed(int index, DoubleBuffer buffer); /** * Store this matrix in row-major order into the supplied {@link ByteBuffer} at the current * buffer {@link ByteBuffer#position() position}. *

* This method will not increment the position of the given ByteBuffer. *

* In order to specify the offset into the ByteBuffer at which * the matrix is stored, use {@link #getTransposed(int, ByteBuffer)}, taking * the absolute position as parameter. * * @see #getTransposed(int, ByteBuffer) * * @param buffer * will receive the values of this matrix in row-major order at its current position * @return the passed in buffer */ ByteBuffer getTransposed(ByteBuffer buffer); /** * Store this matrix in row-major order into the supplied {@link ByteBuffer} starting at the specified * absolute buffer position/index. *

* This method will not increment the position of the given ByteBuffer. * * @param index * the absolute position into the ByteBuffer * @param buffer * will receive the values of this matrix in row-major order * @return the passed in buffer */ ByteBuffer getTransposed(int index, ByteBuffer buffer); /** * Store this matrix in row-major order into the supplied {@link FloatBuffer} at the current * buffer {@link FloatBuffer#position() position}. *

* This method will not increment the position of the given FloatBuffer. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given FloatBuffer. *

* In order to specify the offset into the FloatBuffer at which * the matrix is stored, use {@link #getTransposed(int, FloatBuffer)}, taking * the absolute position as parameter. * * @see #getTransposed(int, FloatBuffer) * * @param buffer * will receive the values of this matrix in row-major order at its current position * @return the passed in buffer */ FloatBuffer getTransposed(FloatBuffer buffer); /** * Store this matrix in row-major order into the supplied {@link FloatBuffer} starting at the specified * absolute buffer position/index. *

* This method will not increment the position of the given FloatBuffer. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given FloatBuffer. * * @param index * the absolute position into the FloatBuffer * @param buffer * will receive the values of this matrix in row-major order * @return the passed in buffer */ FloatBuffer getTransposed(int index, FloatBuffer buffer); /** * Store this matrix as float values in row-major order into the supplied {@link ByteBuffer} at the current * buffer {@link ByteBuffer#position() position}. *

* This method will not increment the position of the given ByteBuffer. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given FloatBuffer. *

* In order to specify the offset into the ByteBuffer at which * the matrix is stored, use {@link #getTransposedFloats(int, ByteBuffer)}, taking * the absolute position as parameter. * * @see #getTransposedFloats(int, ByteBuffer) * * @param buffer * will receive the values of this matrix as float values in row-major order at its current position * @return the passed in buffer */ ByteBuffer getTransposedFloats(ByteBuffer buffer); /** * Store this matrix in row-major order into the supplied {@link ByteBuffer} starting at the specified * absolute buffer position/index. *

* This method will not increment the position of the given ByteBuffer. *

* Please note that due to this matrix storing double values those values will potentially * lose precision when they are converted to float values before being put into the given FloatBuffer. * * @param index * the absolute position into the ByteBuffer * @param buffer * will receive the values of this matrix as float values in row-major order * @return the passed in buffer */ ByteBuffer getTransposedFloats(int index, ByteBuffer buffer); /** * Store this matrix into the supplied float array in row-major order at the given offset. * * @param arr * the array to write the matrix values into * @param offset * the offset into the array * @return the passed in array */ double[] getTransposed(double[] arr, int offset); /** * Store this matrix into the supplied float array in row-major order. *

* In order to specify an explicit offset into the array, use the method {@link #getTransposed(double[], int)}. * * @see #getTransposed(double[], int) * * @param arr * the array to write the matrix values into * @return the passed in array */ double[] getTransposed(double[] arr); /** * Transform/multiply the given vector by this matrix and store the result in that vector. * * @see Vector4d#mul(Matrix4x3dc) * * @param v * the vector to transform and to hold the final result * @return v */ Vector4d transform(Vector4d v); /** * Transform/multiply the given vector by this matrix and store the result in dest. * * @see Vector4d#mul(Matrix4x3dc, Vector4d) * * @param v * the vector to transform * @param dest * will contain the result * @return dest */ Vector4d transform(Vector4dc v, Vector4d dest); /** * Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by * this matrix and store the result in that vector. *

* The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it * will represent a position/location in 3D-space rather than a direction. *

* In order to store the result in another vector, use {@link #transformPosition(Vector3dc, Vector3d)}. * * @see #transformPosition(Vector3dc, Vector3d) * @see #transform(Vector4d) * * @param v * the vector to transform and to hold the final result * @return v */ Vector3d transformPosition(Vector3d v); /** * Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by * this matrix and store the result in dest. *

* The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it * will represent a position/location in 3D-space rather than a direction. *

* In order to store the result in the same vector, use {@link #transformPosition(Vector3d)}. * * @see #transformPosition(Vector3d) * @see #transform(Vector4dc, Vector4d) * * @param v * the vector to transform * @param dest * will hold the result * @return dest */ Vector3d transformPosition(Vector3dc v, Vector3d dest); /** * Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by * this matrix and store the result in that vector. *

* The given 3D-vector is treated as a 4D-vector with its w-component being 0.0, so it * will represent a direction in 3D-space rather than a position. This method will therefore * not take the translation part of the matrix into account. *

* In order to store the result in another vector, use {@link #transformDirection(Vector3dc, Vector3d)}. * * @param v * the vector to transform and to hold the final result * @return v */ Vector3d transformDirection(Vector3d v); /** * Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by * this matrix and store the result in dest. *

* The given 3D-vector is treated as a 4D-vector with its w-component being 0.0, so it * will represent a direction in 3D-space rather than a position. This method will therefore * not take the translation part of the matrix into account. *

* In order to store the result in the same vector, use {@link #transformDirection(Vector3d)}. * * @param v * the vector to transform and to hold the final result * @param dest * will hold the result * @return dest */ Vector3d transformDirection(Vector3dc v, Vector3d dest); /** * Apply scaling to this matrix by scaling the base axes by the given xyz.x, * xyz.y and xyz.z factors, respectively and store the result in dest. *

* If M is this matrix and S the scaling matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v * , the scaling will be applied first! * * @param xyz * the factors of the x, y and z component, respectively * @param dest * will hold the result * @return dest */ Matrix4x3d scale(Vector3dc xyz, Matrix4x3d dest); /** * Apply scaling to this matrix by scaling the base axes by the given x, * y and z factors and store the result in dest. *

* If M is this matrix and S the scaling matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v * , the scaling will be applied first! * * @param x * the factor of the x component * @param y * the factor of the y component * @param z * the factor of the z component * @param dest * will hold the result * @return dest */ Matrix4x3d scale(double x, double y, double z, Matrix4x3d dest); /** * Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor * and store the result in dest. *

* If M is this matrix and S the scaling matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v * , the scaling will be applied first! * * @see #scale(double, double, double, Matrix4x3d) * * @param xyz * the factor for all components * @param dest * will hold the result * @return dest */ Matrix4x3d scale(double xyz, Matrix4x3d dest); /** * Apply scaling to this matrix by by scaling the X axis by x and the Y axis by y * and store the result in dest. *

* If M is this matrix and S the scaling matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v, the * scaling will be applied first! * * @param x * the factor of the x component * @param y * the factor of the y component * @param dest * will hold the result * @return dest */ Matrix4x3d scaleXY(double x, double y, Matrix4x3d dest); /** * Pre-multiply scaling to this matrix by scaling the base axes by the given x, * y and z factors and store the result in dest. *

* If M is this matrix and S the scaling matrix, * then the new matrix will be S * M. So when transforming a * vector v with the new matrix by using S * M * v * , the scaling will be applied last! * * @param x * the factor of the x component * @param y * the factor of the y component * @param z * the factor of the z component * @param dest * will hold the result * @return dest */ Matrix4x3d scaleLocal(double x, double y, double z, Matrix4x3d dest); /** * Apply rotation to this matrix by rotating the given amount of radians * about the given axis specified as x, y and z components and store the result in dest. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v * , the rotation will be applied first! * * @param ang * the angle is in radians * @param x * the x component of the axis * @param y * the y component of the axis * @param z * the z component of the axis * @param dest * will hold the result * @return dest */ Matrix4x3d rotate(double ang, double x, double y, double z, Matrix4x3d dest); /** * Apply rotation to this matrix, which is assumed to only contain a translation, by rotating the given amount of radians * about the specified (x, y, z) axis and store the result in dest. *

* This method assumes this to only contain a translation. *

* The axis described by the three components needs to be a unit vector. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param ang * the angle in radians * @param x * the x component of the axis * @param y * the y component of the axis * @param z * the z component of the axis * @param dest * will hold the result * @return dest */ Matrix4x3d rotateTranslation(double ang, double x, double y, double z, Matrix4x3d dest); /** * Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix while using (ox, oy, oz) as the rotation origin, * and store the result in dest. *

* 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. *

* If M is this matrix and Q the rotation matrix obtained from the given quaternion, * then the new matrix will be M * Q. So when transforming a * vector v with the new matrix by using M * Q * v, * the quaternion rotation will be applied first! *

* This method is equivalent to calling: translate(ox, oy, oz, dest).rotate(quat).translate(-ox, -oy, -oz) *

* Reference: http://en.wikipedia.org * * @param quat * the {@link Quaterniondc} * @param ox * the x coordinate of the rotation origin * @param oy * the y coordinate of the rotation origin * @param oz * the z coordinate of the rotation origin * @param dest * will hold the result * @return dest */ Matrix4x3d rotateAround(Quaterniondc quat, double ox, double oy, double oz, Matrix4x3d dest); /** * Pre-multiply a rotation to this matrix by rotating the given amount of radians * about the specified (x, y, z) axis and store the result in dest. *

* The axis described by the three components needs to be a unit vector. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be R * M. So when transforming a * vector v with the new matrix by using R * M * v, the * rotation will be applied last! *

* Reference: http://en.wikipedia.org * * @param ang * the angle in radians * @param x * the x component of the axis * @param y * the y component of the axis * @param z * the z component of the axis * @param dest * will hold the result * @return dest */ Matrix4x3d rotateLocal(double ang, double x, double y, double z, Matrix4x3d dest); /** * Apply a translation to this matrix by translating by the given number of * units in x, y and z and store the result in dest. *

* If M is this matrix and T the translation * matrix, then the new matrix will be M * T. So when * transforming a vector v with the new matrix by using * M * T * v, the translation will be applied first! * * @param offset * the number of units in x, y and z by which to translate * @param dest * will hold the result * @return dest */ Matrix4x3d translate(Vector3dc offset, Matrix4x3d dest); /** * Apply a translation to this matrix by translating by the given number of * units in x, y and z and store the result in dest. *

* If M is this matrix and T the translation * matrix, then the new matrix will be M * T. So when * transforming a vector v with the new matrix by using * M * T * v, the translation will be applied first! * * @param offset * the number of units in x, y and z by which to translate * @param dest * will hold the result * @return dest */ Matrix4x3d translate(Vector3fc offset, Matrix4x3d dest); /** * Apply a translation to this matrix by translating by the given number of * units in x, y and z and store the result in dest. *

* If M is this matrix and T the translation * matrix, then the new matrix will be M * T. So when * transforming a vector v with the new matrix by using * M * T * v, the translation will be applied first! * * @param x * the offset to translate in x * @param y * the offset to translate in y * @param z * the offset to translate in z * @param dest * will hold the result * @return dest */ Matrix4x3d translate(double x, double y, double z, Matrix4x3d dest); /** * Pre-multiply a translation to this matrix by translating by the given number of * units in x, y and z and store the result in dest. *

* If M is this matrix and T the translation * matrix, then the new matrix will be T * M. So when * transforming a vector v with the new matrix by using * T * M * v, the translation will be applied last! * * @param offset * the number of units in x, y and z by which to translate * @param dest * will hold the result * @return dest */ Matrix4x3d translateLocal(Vector3fc offset, Matrix4x3d dest); /** * Pre-multiply a translation to this matrix by translating by the given number of * units in x, y and z and store the result in dest. *

* If M is this matrix and T the translation * matrix, then the new matrix will be T * M. So when * transforming a vector v with the new matrix by using * T * M * v, the translation will be applied last! * * @param offset * the number of units in x, y and z by which to translate * @param dest * will hold the result * @return dest */ Matrix4x3d translateLocal(Vector3dc offset, Matrix4x3d dest); /** * Pre-multiply a translation to this matrix by translating by the given number of * units in x, y and z and store the result in dest. *

* If M is this matrix and T the translation * matrix, then the new matrix will be T * M. So when * transforming a vector v with the new matrix by using * T * M * v, the translation will be applied last! * * @param x * the offset to translate in x * @param y * the offset to translate in y * @param z * the offset to translate in z * @param dest * will hold the result * @return dest */ Matrix4x3d translateLocal(double x, double y, double z, Matrix4x3d dest); /** * Apply rotation about the X axis to this matrix by rotating the given amount of radians * and store the result in dest. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param ang * the angle in radians * @param dest * will hold the result * @return dest */ Matrix4x3d rotateX(double ang, Matrix4x3d dest); /** * Apply rotation about the Y axis to this matrix by rotating the given amount of radians * and store the result in dest. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param ang * the angle in radians * @param dest * will hold the result * @return dest */ Matrix4x3d rotateY(double ang, Matrix4x3d dest); /** * Apply rotation about the Z axis to this matrix by rotating the given amount of radians * and store the result in dest. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param ang * the angle in radians * @param dest * will hold the result * @return dest */ Matrix4x3d rotateZ(double ang, Matrix4x3d dest); /** * Apply rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and * followed by a rotation of angleZ radians about the Z axis and store the result in dest. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * rotation will be applied first! *

* This method is equivalent to calling: rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ) * * @param angleX * the angle to rotate about X * @param angleY * the angle to rotate about Y * @param angleZ * the angle to rotate about Z * @param dest * will hold the result * @return dest */ Matrix4x3d rotateXYZ(double angleX, double angleY, double angleZ, Matrix4x3d dest); /** * Apply rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and * followed by a rotation of angleX radians about the X axis and store the result in dest. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * rotation will be applied first! *

* This method is equivalent to calling: rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX) * * @param angleZ * the angle to rotate about Z * @param angleY * the angle to rotate about Y * @param angleX * the angle to rotate about X * @param dest * will hold the result * @return dest */ Matrix4x3d rotateZYX(double angleZ, double angleY, double angleX, Matrix4x3d dest); /** * Apply rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and * followed by a rotation of angleZ radians about the Z axis and store the result in dest. *

* 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. *

* If M is this matrix and R the rotation matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * rotation will be applied first! *

* This method is equivalent to calling: rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ) * * @param angleY * the angle to rotate about Y * @param angleX * the angle to rotate about X * @param angleZ * the angle to rotate about Z * @param dest * will hold the result * @return dest */ Matrix4x3d rotateYXZ(double angleY, double angleX, double angleZ, Matrix4x3d dest); /** * Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix and store * the result in dest. *

* 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. *

* If M is this matrix and Q the rotation matrix obtained from the given quaternion, * then the new matrix will be M * Q. So when transforming a * vector v with the new matrix by using M * Q * v, * the quaternion rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param quat * the {@link Quaterniondc} * @param dest * will hold the result * @return dest */ Matrix4x3d rotate(Quaterniondc quat, Matrix4x3d dest); /** * Apply the rotation - and possibly scaling - transformation of the given {@link Quaternionfc} to this matrix and store * the result in dest. *

* 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. *

* If M is this matrix and Q the rotation matrix obtained from the given quaternion, * then the new matrix will be M * Q. So when transforming a * vector v with the new matrix by using M * Q * v, * the quaternion rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param quat * the {@link Quaternionfc} * @param dest * will hold the result * @return dest */ Matrix4x3d rotate(Quaternionfc quat, Matrix4x3d dest); /** * Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix, which is assumed to only contain a translation, and store * the result in dest. *

* This method assumes this to only contain a translation. *

* 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. *

* If M is this matrix and Q the rotation matrix obtained from the given quaternion, * then the new matrix will be M * Q. So when transforming a * vector v with the new matrix by using M * Q * v, * the quaternion rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param quat * the {@link Quaterniondc} * @param dest * will hold the result * @return dest */ Matrix4x3d rotateTranslation(Quaterniondc quat, Matrix4x3d dest); /** * Apply the rotation - and possibly scaling - transformation of the given {@link Quaternionfc} to this matrix, which is assumed to only contain a translation, and store * the result in dest. *

* This method assumes this to only contain a translation. *

* 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. *

* If M is this matrix and Q the rotation matrix obtained from the given quaternion, * then the new matrix will be M * Q. So when transforming a * vector v with the new matrix by using M * Q * v, * the quaternion rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @param quat * the {@link Quaternionfc} * @param dest * will hold the result * @return dest */ Matrix4x3d rotateTranslation(Quaternionfc quat, Matrix4x3d dest); /** * Pre-multiply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix and store * the result in dest. *

* 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. *

* If M is this matrix and Q the rotation matrix obtained from the given quaternion, * then the new matrix will be Q * M. So when transforming a * vector v with the new matrix by using Q * M * v, * the quaternion rotation will be applied last! *

* Reference: http://en.wikipedia.org * * @param quat * the {@link Quaterniondc} * @param dest * will hold the result * @return dest */ Matrix4x3d rotateLocal(Quaterniondc quat, Matrix4x3d dest); /** * Pre-multiply the rotation - and possibly scaling - transformation of the given {@link Quaternionfc} to this matrix and store * the result in dest. *

* 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. *

* If M is this matrix and Q the rotation matrix obtained from the given quaternion, * then the new matrix will be Q * M. So when transforming a * vector v with the new matrix by using Q * M * v, * the quaternion rotation will be applied last! *

* Reference: http://en.wikipedia.org * * @param quat * the {@link Quaternionfc} * @param dest * will hold the result * @return dest */ Matrix4x3d rotateLocal(Quaternionfc quat, Matrix4x3d dest); /** * Apply a rotation transformation, rotating about the given {@link AxisAngle4f} and store the result in dest. *

* The axis described by the axis vector needs to be a unit vector. *

* 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. *

* If M is this matrix and A the rotation matrix obtained from the given {@link AxisAngle4f}, * then the new matrix will be M * A. So when transforming a * vector v with the new matrix by using M * A * v, * the {@link AxisAngle4f} rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @see #rotate(double, double, double, double, Matrix4x3d) * * @param axisAngle * the {@link AxisAngle4f} (needs to be {@link AxisAngle4f#normalize() normalized}) * @param dest * will hold the result * @return dest */ Matrix4x3d rotate(AxisAngle4f axisAngle, Matrix4x3d dest); /** * Apply a rotation transformation, rotating about the given {@link AxisAngle4d} and store the result in dest. *

* 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. *

* If M is this matrix and A the rotation matrix obtained from the given {@link AxisAngle4d}, * then the new matrix will be M * A. So when transforming a * vector v with the new matrix by using M * A * v, * the {@link AxisAngle4d} rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @see #rotate(double, double, double, double, Matrix4x3d) * * @param axisAngle * the {@link AxisAngle4d} (needs to be {@link AxisAngle4d#normalize() normalized}) * @param dest * will hold the result * @return dest */ Matrix4x3d rotate(AxisAngle4d axisAngle, Matrix4x3d dest); /** * Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest. *

* 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. *

* If M is this matrix and A the rotation matrix obtained from the given angle and axis, * then the new matrix will be M * A. So when transforming a * vector v with the new matrix by using M * A * v, * the axis-angle rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @see #rotate(double, double, double, double, Matrix4x3d) * * @param angle * the angle in radians * @param axis * the rotation axis (needs to be {@link Vector3d#normalize() normalized}) * @param dest * will hold the result * @return dest */ Matrix4x3d rotate(double angle, Vector3dc axis, Matrix4x3d dest); /** * Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest. *

* 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. *

* If M is this matrix and A the rotation matrix obtained from the given angle and axis, * then the new matrix will be M * A. So when transforming a * vector v with the new matrix by using M * A * v, * the axis-angle rotation will be applied first! *

* Reference: http://en.wikipedia.org * * @see #rotate(double, double, double, double, Matrix4x3d) * * @param angle * the angle in radians * @param axis * the rotation axis (needs to be {@link Vector3f#normalize() normalized}) * @param dest * will hold the result * @return dest */ Matrix4x3d rotate(double angle, Vector3fc axis, Matrix4x3d dest); /** * Get the row at the given row index, starting with 0. * * @param row * the row index in [0..2] * @param dest * will hold the row components * @return the passed in destination * @throws IndexOutOfBoundsException if row is not in [0..2] */ Vector4d getRow(int row, Vector4d dest) throws IndexOutOfBoundsException; /** * Get the column at the given column index, starting with 0. * * @param column * the column index in [0..3] * @param dest * will hold the column components * @return the passed in destination * @throws IndexOutOfBoundsException if column is not in [0..3] */ Vector3d getColumn(int column, Vector3d dest) throws IndexOutOfBoundsException; /** * Compute a normal matrix from the left 3x3 submatrix of this * and store it into the left 3x3 submatrix of dest. * All other values of dest will be set to identity. *

* The normal matrix of m is the transpose of the inverse of m. * * @param dest * will hold the result * @return dest */ Matrix4x3d normal(Matrix4x3d dest); /** * Compute a normal matrix from the left 3x3 submatrix of this * and store it into dest. *

* The normal matrix of m is the transpose of the inverse of m. * * @param dest * will hold the result * @return dest */ Matrix3d normal(Matrix3d dest); /** * Compute the cofactor matrix of the left 3x3 submatrix of this * and store it into dest. *

* 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. * * @param dest * will hold the result * @return dest */ Matrix3d cofactor3x3(Matrix3d dest); /** * Compute the cofactor matrix of the left 3x3 submatrix of this * and store it into dest. * All other values of dest will be set to identity. *

* The cofactor matrix can be used instead of {@link #normal(Matrix4x3d)} to transform normals * when the orientation of the normals with respect to the surface should be preserved. * * @param dest * will hold the result * @return dest */ Matrix4x3d cofactor3x3(Matrix4x3d dest); /** * Normalize the left 3x3 submatrix of this matrix and store the result in dest. *

* 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 skewing). * * @param dest * will hold the result * @return dest */ Matrix4x3d normalize3x3(Matrix4x3d dest); /** * Normalize the left 3x3 submatrix of this matrix and store the result in dest. *

* 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 skewing). * * @param dest * will hold the result * @return dest */ Matrix3d normalize3x3(Matrix3d dest); /** * Apply a mirror/reflection transformation to this matrix that reflects about the given plane * specified via the equation x*a + y*b + z*c + d = 0 and store the result in dest. *

* The vector (a, b, c) must be a unit vector. *

* If M is this matrix and R the reflection matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * reflection will be applied first! *

* Reference: msdn.microsoft.com * * @param a * the x factor in the plane equation * @param b * the y factor in the plane equation * @param c * the z factor in the plane equation * @param d * the constant in the plane equation * @param dest * will hold the result * @return dest */ Matrix4x3d reflect(double a, double b, double c, double d, Matrix4x3d dest); /** * 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, and store the result in dest. *

* If M is this matrix and R the reflection matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * reflection will be applied first! * * @param nx * the x-coordinate of the plane normal * @param ny * the y-coordinate of the plane normal * @param nz * the z-coordinate of the plane normal * @param px * the x-coordinate of a point on the plane * @param py * the y-coordinate of a point on the plane * @param pz * the z-coordinate of a point on the plane * @param dest * will hold the result * @return dest */ Matrix4x3d reflect(double nx, double ny, double nz, double px, double py, double pz, Matrix4x3d dest); /** * Apply a mirror/reflection transformation to this matrix that reflects about a plane * specified via the plane orientation and a point on the plane, and store the result in dest. *

* 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 (0, 0, 1). So, if the given {@link Quaterniondc} is * the identity (does not apply any additional rotation), the reflection plane will be z=0, offset by the given point. *

* If M is this matrix and R the reflection matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * reflection will be applied first! * * @param orientation * the plane orientation * @param point * a point on the plane * @param dest * will hold the result * @return dest */ Matrix4x3d reflect(Quaterniondc orientation, Vector3dc point, Matrix4x3d dest); /** * 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, and store the result in dest. *

* If M is this matrix and R the reflection matrix, * then the new matrix will be M * R. So when transforming a * vector v with the new matrix by using M * R * v, the * reflection will be applied first! * * @param normal * the plane normal * @param point * a point on the plane * @param dest * will hold the result * @return dest */ Matrix4x3d reflect(Vector3dc normal, Vector3dc point, Matrix4x3d dest); /** * Apply an orthographic projection transformation for a right-handed coordinate system * using the given NDC z range to this matrix and store the result in dest. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param left * the distance from the center to the left frustum edge * @param right * the distance from the center to the right frustum edge * @param bottom * the distance from the center to the bottom frustum edge * @param top * the distance from the center to the top frustum edge * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param zZeroToOne * whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true * or whether to use OpenGL's NDC z range of [-1..+1] when false * @param dest * will hold the result * @return dest */ Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, boolean zZeroToOne, Matrix4x3d dest); /** * Apply an orthographic projection transformation for a right-handed coordinate system * using OpenGL's NDC z range of [-1..+1] to this matrix and store the result in dest. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param left * the distance from the center to the left frustum edge * @param right * the distance from the center to the right frustum edge * @param bottom * the distance from the center to the bottom frustum edge * @param top * the distance from the center to the top frustum edge * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param dest * will hold the result * @return dest */ Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest); /** * Apply an orthographic projection transformation for a left-handed coordiante system * using the given NDC z range to this matrix and store the result in dest. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param left * the distance from the center to the left frustum edge * @param right * the distance from the center to the right frustum edge * @param bottom * the distance from the center to the bottom frustum edge * @param top * the distance from the center to the top frustum edge * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param zZeroToOne * whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true * or whether to use OpenGL's NDC z range of [-1..+1] when false * @param dest * will hold the result * @return dest */ Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, boolean zZeroToOne, Matrix4x3d dest); /** * Apply an orthographic projection transformation for a left-handed coordiante system * using OpenGL's NDC z range of [-1..+1] to this matrix and store the result in dest. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param left * the distance from the center to the left frustum edge * @param right * the distance from the center to the right frustum edge * @param bottom * the distance from the center to the bottom frustum edge * @param top * the distance from the center to the top frustum edge * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param dest * will hold the result * @return dest */ Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest); /** * Apply a symmetric orthographic projection transformation for a right-handed coordinate system * using the given NDC z range to this matrix and store the result in dest. *

* This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, boolean, Matrix4x3d) ortho()} with * left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param width * the distance between the right and left frustum edges * @param height * the distance between the top and bottom frustum edges * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param dest * will hold the result * @param zZeroToOne * whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true * or whether to use OpenGL's NDC z range of [-1..+1] when false * @return dest */ Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, boolean zZeroToOne, Matrix4x3d dest); /** * Apply a symmetric orthographic projection transformation for a right-handed coordinate system * using OpenGL's NDC z range of [-1..+1] to this matrix and store the result in dest. *

* This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4x3d) ortho()} with * left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param width * the distance between the right and left frustum edges * @param height * the distance between the top and bottom frustum edges * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param dest * will hold the result * @return dest */ Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, Matrix4x3d dest); /** * Apply a symmetric orthographic projection transformation for a left-handed coordinate system * using the given NDC z range to this matrix and store the result in dest. *

* This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, boolean, Matrix4x3d) orthoLH()} with * left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param width * the distance between the right and left frustum edges * @param height * the distance between the top and bottom frustum edges * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param dest * will hold the result * @param zZeroToOne * whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true * or whether to use OpenGL's NDC z range of [-1..+1] when false * @return dest */ Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, boolean zZeroToOne, Matrix4x3d dest); /** * Apply a symmetric orthographic projection transformation for a left-handed coordinate system * using OpenGL's NDC z range of [-1..+1] to this matrix and store the result in dest. *

* This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4x3d) orthoLH()} with * left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @param width * the distance between the right and left frustum edges * @param height * the distance between the top and bottom frustum edges * @param zNear * near clipping plane distance * @param zFar * far clipping plane distance * @param dest * will hold the result * @return dest */ Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, Matrix4x3d dest); /** * Apply an orthographic projection transformation for a right-handed coordinate system * to this matrix and store the result in dest. *

* This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4x3d) ortho()} with * zNear=-1 and zFar=+1. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @see #ortho(double, double, double, double, double, double, Matrix4x3d) * * @param left * the distance from the center to the left frustum edge * @param right * the distance from the center to the right frustum edge * @param bottom * the distance from the center to the bottom frustum edge * @param top * the distance from the center to the top frustum edge * @param dest * will hold the result * @return dest */ Matrix4x3d ortho2D(double left, double right, double bottom, double top, Matrix4x3d dest); /** * Apply an orthographic projection transformation for a left-handed coordinate system to this matrix and store the result in dest. *

* This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4x3d) orthoLH()} with * zNear=-1 and zFar=+1. *

* If M is this matrix and O the orthographic projection matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * orthographic projection transformation will be applied first! *

* Reference: http://www.songho.ca * * @see #orthoLH(double, double, double, double, double, double, Matrix4x3d) * * @param left * the distance from the center to the left frustum edge * @param right * the distance from the center to the right frustum edge * @param bottom * the distance from the center to the bottom frustum edge * @param top * the distance from the center to the top frustum edge * @param dest * will hold the result * @return dest */ Matrix4x3d ortho2DLH(double left, double right, double bottom, double top, Matrix4x3d dest); /** * Apply a rotation transformation to this matrix to make -z point along dir * and store the result in dest. *

* If M is this matrix and L the lookalong rotation matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, the * lookalong rotation transformation will be applied first! *

* This is equivalent to calling * {@link #lookAt(Vector3dc, Vector3dc, Vector3dc, Matrix4x3d) lookAt} * with eye = (0, 0, 0) and center = dir. * * @see #lookAlong(double, double, double, double, double, double, Matrix4x3d) * @see #lookAt(Vector3dc, Vector3dc, Vector3dc, Matrix4x3d) * * @param dir * the direction in space to look along * @param up * the direction of 'up' * @param dest * will hold the result * @return dest */ Matrix4x3d lookAlong(Vector3dc dir, Vector3dc up, Matrix4x3d dest); /** * Apply a rotation transformation to this matrix to make -z point along dir * and store the result in dest. *

* If M is this matrix and L the lookalong rotation matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, the * lookalong rotation transformation will be applied first! *

* This is equivalent to calling * {@link #lookAt(double, double, double, double, double, double, double, double, double, Matrix4x3d) lookAt()} * with eye = (0, 0, 0) and center = dir. * * @see #lookAt(double, double, double, double, double, double, double, double, double, Matrix4x3d) * * @param dirX * the x-coordinate of the direction to look along * @param dirY * the y-coordinate of the direction to look along * @param dirZ * the z-coordinate of the direction to look along * @param upX * the x-coordinate of the up vector * @param upY * the y-coordinate of the up vector * @param upZ * the z-coordinate of the up vector * @param dest * will hold the result * @return dest */ Matrix4x3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest); /** * Apply a "lookat" transformation to this matrix for a right-handed coordinate system, * that aligns -z with center - eye and store the result in dest. *

* If M is this matrix and L the lookat matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, * the lookat transformation will be applied first! * * @see #lookAt(double, double, double, double, double, double, double, double, double, Matrix4x3d) * * @param eye * the position of the camera * @param center * the point in space to look at * @param up * the direction of 'up' * @param dest * will hold the result * @return dest */ Matrix4x3d lookAt(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4x3d dest); /** * Apply a "lookat" transformation to this matrix for a right-handed coordinate system, * that aligns -z with center - eye and store the result in dest. *

* If M is this matrix and L the lookat matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, * the lookat transformation will be applied first! * * @see #lookAt(Vector3dc, Vector3dc, Vector3dc, Matrix4x3d) * * @param eyeX * the x-coordinate of the eye/camera location * @param eyeY * the y-coordinate of the eye/camera location * @param eyeZ * the z-coordinate of the eye/camera location * @param centerX * the x-coordinate of the point to look at * @param centerY * the y-coordinate of the point to look at * @param centerZ * the z-coordinate of the point to look at * @param upX * the x-coordinate of the up vector * @param upY * the y-coordinate of the up vector * @param upZ * the z-coordinate of the up vector * @param dest * will hold the result * @return dest */ Matrix4x3d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest); /** * Apply a "lookat" transformation to this matrix for a left-handed coordinate system, * that aligns +z with center - eye and store the result in dest. *

* If M is this matrix and L the lookat matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, * the lookat transformation will be applied first! * * @see #lookAtLH(double, double, double, double, double, double, double, double, double, Matrix4x3d) * * @param eye * the position of the camera * @param center * the point in space to look at * @param up * the direction of 'up' * @param dest * will hold the result * @return dest */ Matrix4x3d lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4x3d dest); /** * Apply a "lookat" transformation to this matrix for a left-handed coordinate system, * that aligns +z with center - eye and store the result in dest. *

* If M is this matrix and L the lookat matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, * the lookat transformation will be applied first! * * @see #lookAtLH(Vector3dc, Vector3dc, Vector3dc, Matrix4x3d) * * @param eyeX * the x-coordinate of the eye/camera location * @param eyeY * the y-coordinate of the eye/camera location * @param eyeZ * the z-coordinate of the eye/camera location * @param centerX * the x-coordinate of the point to look at * @param centerY * the y-coordinate of the point to look at * @param centerZ * the z-coordinate of the point to look at * @param upX * the x-coordinate of the up vector * @param upY * the y-coordinate of the up vector * @param upZ * the z-coordinate of the up vector * @param dest * will hold the result * @return dest */ Matrix4x3d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest); /** * Calculate a frustum plane of this matrix, which * can be a projection matrix or a combined modelview-projection matrix, and store the result * in the given plane. *

* Generally, this method computes the frustum plane in the local frame of * any coordinate system that existed before this * transformation was applied to it in order to yield homogeneous clipping space. *

* The plane normal, which is (a, b, c), is directed "inwards" of the frustum. * Any plane/point test using a*x + b*y + c*z + d therefore will yield a result greater than zero * if the point is within the frustum (i.e. at the positive side of the frustum plane). *

* Reference: * Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix * * @param which * one of the six possible planes, given as numeric constants * {@link #PLANE_NX}, {@link #PLANE_PX}, * {@link #PLANE_NY}, {@link #PLANE_PY}, * {@link #PLANE_NZ} and {@link #PLANE_PZ} * @param plane * will hold the computed plane equation. * The plane equation will be normalized, meaning that (a, b, c) will be a unit vector * @return planeEquation */ Planed frustumPlane(int which, Planed plane); /** * Obtain the direction of +Z before the transformation represented by this matrix is applied. *

* This method uses the rotation component of the left 3x3 submatrix to obtain the direction * that is transformed to +Z by this matrix. *

* This method is equivalent to the following code: *

     * Matrix4x3d inv = new Matrix4x3d(this).invert();
     * inv.transformDirection(dir.set(0, 0, 1)).normalize();
     * 
* If this is already an orthogonal matrix, then consider using {@link #normalizedPositiveZ(Vector3d)} instead. *

* Reference: http://www.euclideanspace.com * * @param dir * will hold the direction of +Z * @return dir */ Vector3d positiveZ(Vector3d dir); /** * Obtain the direction of +Z before the transformation represented by this orthogonal matrix is applied. * This method only produces correct results if this is an orthogonal matrix. *

* This method uses the rotation component of the left 3x3 submatrix to obtain the direction * that is transformed to +Z by this matrix. *

* This method is equivalent to the following code: *

     * Matrix4x3d inv = new Matrix4x3d(this).transpose();
     * inv.transformDirection(dir.set(0, 0, 1)).normalize();
     * 
*

* Reference: http://www.euclideanspace.com * * @param dir * will hold the direction of +Z * @return dir */ Vector3d normalizedPositiveZ(Vector3d dir); /** * Obtain the direction of +X before the transformation represented by this matrix is applied. *

* This method uses the rotation component of the left 3x3 submatrix to obtain the direction * that is transformed to +X by this matrix. *

* This method is equivalent to the following code: *

     * Matrix4x3d inv = new Matrix4x3d(this).invert();
     * inv.transformDirection(dir.set(1, 0, 0)).normalize();
     * 
* If this is already an orthogonal matrix, then consider using {@link #normalizedPositiveX(Vector3d)} instead. *

* Reference: http://www.euclideanspace.com * * @param dir * will hold the direction of +X * @return dir */ Vector3d positiveX(Vector3d dir); /** * Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied. * This method only produces correct results if this is an orthogonal matrix. *

* This method uses the rotation component of the left 3x3 submatrix to obtain the direction * that is transformed to +X by this matrix. *

* This method is equivalent to the following code: *

     * Matrix4x3d inv = new Matrix4x3d(this).transpose();
     * inv.transformDirection(dir.set(1, 0, 0)).normalize();
     * 
*

* Reference: http://www.euclideanspace.com * * @param dir * will hold the direction of +X * @return dir */ Vector3d normalizedPositiveX(Vector3d dir); /** * Obtain the direction of +Y before the transformation represented by this matrix is applied. *

* This method uses the rotation component of the left 3x3 submatrix to obtain the direction * that is transformed to +Y by this matrix. *

* This method is equivalent to the following code: *

     * Matrix4x3d inv = new Matrix4x3d(this).invert();
     * inv.transformDirection(dir.set(0, 1, 0)).normalize();
     * 
* If this is already an orthogonal matrix, then consider using {@link #normalizedPositiveY(Vector3d)} instead. *

* Reference: http://www.euclideanspace.com * * @param dir * will hold the direction of +Y * @return dir */ Vector3d positiveY(Vector3d dir); /** * Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied. * This method only produces correct results if this is an orthogonal matrix. *

* This method uses the rotation component of the left 3x3 submatrix to obtain the direction * that is transformed to +Y by this matrix. *

* This method is equivalent to the following code: *

     * Matrix4x3d inv = new Matrix4x3d(this).transpose();
     * inv.transformDirection(dir.set(0, 1, 0)).normalize();
     * 
*

* Reference: http://www.euclideanspace.com * * @param dir * will hold the direction of +Y * @return dir */ Vector3d normalizedPositiveY(Vector3d dir); /** * Obtain the position that gets transformed to the origin by this matrix. * This can be used to get the position of the "camera" from a given view transformation matrix. *

* This method is equivalent to the following code: *

     * Matrix4x3f inv = new Matrix4x3f(this).invert();
     * inv.transformPosition(origin.set(0, 0, 0));
     * 
* * @param origin * will hold the position transformed to the origin * @return origin */ Vector3d origin(Vector3d origin); /** * Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation * x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction light * and store the result in dest. *

* If light.w is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light. *

* If M is this matrix and S the shadow matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v, the * reflection will be applied first! *

* Reference: ftp.sgi.com * * @param light * the light's vector * @param a * the x factor in the plane equation * @param b * the y factor in the plane equation * @param c * the z factor in the plane equation * @param d * the constant in the plane equation * @param dest * will hold the result * @return dest */ Matrix4x3d shadow(Vector4dc light, double a, double b, double c, double d, Matrix4x3d dest); /** * Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation * x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW) * and store the result in dest. *

* If lightW is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light. *

* If M is this matrix and S the shadow matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v, the * reflection will be applied first! *

* Reference: ftp.sgi.com * * @param lightX * the x-component of the light's vector * @param lightY * the y-component of the light's vector * @param lightZ * the z-component of the light's vector * @param lightW * the w-component of the light's vector * @param a * the x factor in the plane equation * @param b * the y factor in the plane equation * @param c * the z factor in the plane equation * @param d * the constant in the plane equation * @param dest * will hold the result * @return dest */ Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d, Matrix4x3d dest); /** * Apply a projection transformation to this matrix that projects onto the plane with the general plane equation * y = 0 as if casting a shadow from a given light position/direction light * and store the result in dest. *

* Before the shadow projection is applied, the plane is transformed via the specified planeTransformation. *

* If light.w is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light. *

* If M is this matrix and S the shadow matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v, the * reflection will be applied first! * * @param light * the light's vector * @param planeTransform * the transformation to transform the implied plane y = 0 before applying the projection * @param dest * will hold the result * @return dest */ Matrix4x3d shadow(Vector4dc light, Matrix4x3dc planeTransform, Matrix4x3d dest); /** * Apply a projection transformation to this matrix that projects onto the plane with the general plane equation * y = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW) * and store the result in dest. *

* Before the shadow projection is applied, the plane is transformed via the specified planeTransformation. *

* If lightW is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light. *

* If M is this matrix and S the shadow matrix, * then the new matrix will be M * S. So when transforming a * vector v with the new matrix by using M * S * v, the * reflection will be applied first! * * @param lightX * the x-component of the light vector * @param lightY * the y-component of the light vector * @param lightZ * the z-component of the light vector * @param lightW * the w-component of the light vector * @param planeTransform * the transformation to transform the implied plane y = 0 before applying the projection * @param dest * will hold the result * @return dest */ Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4x3dc planeTransform, Matrix4x3d dest); /** * Apply a picking transformation to this matrix using the given window coordinates (x, y) as the pick center * and the given (width, height) as the size of the picking region in window coordinates, and store the result * in dest. * * @param x * the x coordinate of the picking region center in window coordinates * @param y * the y coordinate of the picking region center in window coordinates * @param width * the width of the picking region in window coordinates * @param height * the height of the picking region in window coordinates * @param viewport * the viewport described by [x, y, width, height] * @param dest * the destination matrix, which will hold the result * @return dest */ Matrix4x3d pick(double x, double y, double width, double height, int[] viewport, Matrix4x3d dest); /** * Apply an arcball view transformation to this matrix with the given radius and center (centerX, centerY, centerZ) * position of the arcball and the specified X and Y rotation angles, and store the result in dest. *

* This method is equivalent to calling: translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-centerX, -centerY, -centerZ) * * @param radius * the arcball radius * @param centerX * the x coordinate of the center position of the arcball * @param centerY * the y coordinate of the center position of the arcball * @param centerZ * the z coordinate of the center position of the arcball * @param angleX * the rotation angle around the X axis in radians * @param angleY * the rotation angle around the Y axis in radians * @param dest * will hold the result * @return dest */ Matrix4x3d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY, Matrix4x3d dest); /** * Apply an arcball view transformation to this matrix with the given radius and center * position of the arcball and the specified X and Y rotation angles, and store the result in dest. *

* This method is equivalent to calling: translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-center.x, -center.y, -center.z) * * @param radius * the arcball radius * @param center * the center position of the arcball * @param angleX * the rotation angle around the X axis in radians * @param angleY * the rotation angle around the Y axis in radians * @param dest * will hold the result * @return dest */ Matrix4x3d arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4x3d dest); /** * Transform the axis-aligned box given as the minimum corner (minX, minY, minZ) and maximum corner (maxX, maxY, maxZ) * by this matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin * and maximum corner stored in outMax. *

* Reference: http://dev.theomader.com * * @param minX * the x coordinate of the minimum corner of the axis-aligned box * @param minY * the y coordinate of the minimum corner of the axis-aligned box * @param minZ * the z coordinate of the minimum corner of the axis-aligned box * @param maxX * the x coordinate of the maximum corner of the axis-aligned box * @param maxY * the y coordinate of the maximum corner of the axis-aligned box * @param maxZ * the y coordinate of the maximum corner of the axis-aligned box * @param outMin * will hold the minimum corner of the resulting axis-aligned box * @param outMax * will hold the maximum corner of the resulting axis-aligned box * @return this */ Matrix4x3d transformAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector3d outMin, Vector3d outMax); /** * Transform the axis-aligned box given as the minimum corner min and maximum corner max * by this matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin * and maximum corner stored in outMax. * * @param min * the minimum corner of the axis-aligned box * @param max * the maximum corner of the axis-aligned box * @param outMin * will hold the minimum corner of the resulting axis-aligned box * @param outMax * will hold the maximum corner of the resulting axis-aligned box * @return this */ Matrix4x3d transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax); /** * Linearly interpolate this and other using the given interpolation factor t * and store the result in dest. *

* If t is 0.0 then the result is this. If the interpolation factor is 1.0 * then the result is other. * * @param other * the other matrix * @param t * the interpolation factor between 0.0 and 1.0 * @param dest * will hold the result * @return dest */ Matrix4x3d lerp(Matrix4x3dc other, double t, Matrix4x3d dest); /** * Apply a model transformation to this matrix for a right-handed coordinate system, * that aligns the -z axis with dir * and store the result in dest. *

* If M is this matrix and L the lookat matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, * the lookat transformation will be applied first! *

* This method is equivalent to calling: mul(new Matrix4x3d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invert(), dest) * * @see #rotateTowards(double, double, double, double, double, double, Matrix4x3d) * * @param dir * the direction to rotate towards * @param up * the up vector * @param dest * will hold the result * @return dest */ Matrix4x3d rotateTowards(Vector3dc dir, Vector3dc up, Matrix4x3d dest); /** * Apply a model transformation to this matrix for a right-handed coordinate system, * that aligns the -z axis with (dirX, dirY, dirZ) * and store the result in dest. *

* If M is this matrix and L the lookat matrix, * then the new matrix will be M * L. So when transforming a * vector v with the new matrix by using M * L * v, * the lookat transformation will be applied first! *

* This method is equivalent to calling: mul(new Matrix4x3d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invert(), dest) * * @see #rotateTowards(Vector3dc, Vector3dc, Matrix4x3d) * * @param dirX * the x-coordinate of the direction to rotate towards * @param dirY * the y-coordinate of the direction to rotate towards * @param dirZ * the z-coordinate of the direction to rotate towards * @param upX * the x-coordinate of the up vector * @param upY * the y-coordinate of the up vector * @param upZ * the z-coordinate of the up vector * @param dest * will hold the result * @return dest */ Matrix4x3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest); /** * Extract the Euler angles from the rotation represented by the left 3x3 submatrix of this * and store the extracted Euler angles in dest. *

* This method assumes that the left 3x3 submatrix of this only represents a rotation without scaling. *

* Note that the returned Euler angles must be applied in the order Z * Y * X to obtain the identical matrix. * This means that calling {@link Matrix4x3d#rotateZYX(double, double, double)} using the obtained Euler angles will yield * the same rotation as the original matrix from which the Euler angles were obtained, so in the below code the matrix * m2 should be identical to m (disregarding possible floating-point inaccuracies). *

     * Matrix4x3d m = ...; // <- matrix only representing rotation
     * Matrix4x3d n = new Matrix4x3d();
     * n.rotateZYX(m.getEulerAnglesZYX(new Vector3d()));
     * 
*

* Reference: http://nghiaho.com/ * * @param dest * will hold the extracted Euler angles * @return dest */ Vector3d getEulerAnglesZYX(Vector3d dest); /** * Apply an oblique projection transformation to this matrix with the given values for a and * b and store the result in dest. *

* If M is this matrix and O the oblique transformation matrix, * then the new matrix will be M * O. So when transforming a * vector v with the new matrix by using M * O * v, the * oblique transformation will be applied first! *

* The oblique transformation is defined as: *

     * x' = x + a*z
     * y' = y + a*z
     * z' = z
     * 
* or in matrix form: *
     * 1 0 a 0
     * 0 1 b 0
     * 0 0 1 0
     * 
* * @param a * the value for the z factor that applies to x * @param b * the value for the z factor that applies to y * @param dest * will hold the result * @return dest */ Matrix4x3d obliqueZ(double a, double b, Matrix4x3d dest); /** * Compare the matrix elements of this matrix with the given matrix using the given delta * and return whether all of them are equal within a maximum difference of delta. *

* Please note that this method is not used by any data structure such as {@link ArrayList} {@link HashSet} or {@link HashMap} * and their operations, such as {@link ArrayList#contains(Object)} or {@link HashSet#remove(Object)}, since those * data structures only use the {@link Object#equals(Object)} and {@link Object#hashCode()} methods. * * @param m * the other matrix * @param delta * the allowed maximum difference * @return true whether all of the matrix elements are equal; false otherwise */ boolean equals(Matrix4x3dc m, double delta); /** * Determine whether all matrix elements are finite floating-point values, that * is, they are not {@link Double#isNaN() NaN} and not * {@link Double#isInfinite() infinity}. * * @return {@code true} if all components are finite floating-point values; * {@code false} otherwise */ boolean isFinite(); }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy