Matrix4

Inheritance: java.lang.Object

All Implemented Interfaces: com.aspose.threed.Struct, java.io.Serializable

public final class Matrix4 implements Struct<Matrix4>, Serializable

Implementación de matriz 4x4. Ejemplo:

Matrix4 mat = Matrix4.rotateFromEuler(90, 0, 0);
      Matrix4 mat2 = Matrix4.translate(0, 10, -50);
      Matrix4 transform = Matrix4.mul(mat2, mat);
      Vector4 pos = new Vector4(10, 9, 0, 1);
      Vector4 transformed = Matrix4.mul(transform, pos);

Constructores

Constructor	Descripción
Matrix4(Vector4 r0, Vector4 r1, Vector4 r2, Vector4 r3)	Construye la matriz a partir de 4 filas.
Matrix4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33)	Inicializa una nueva instancia de la estructura Matrix4.
Matrix4(FMatrix4 m)	Construye Matrix4 a partir de una instancia de FMatrix4.
Matrix4(double[] m)	Inicializa una nueva instancia de la estructura Matrix4.
Matrix4()

Campos

Campo	Descripción
m00	El m00.
m01	El m01.
m02	El m02.
m03	El m03.
m10	El m10.
m11	El m11.
m12	El m12.
m13	El m13.
m20	El m20.
m21	El m21.
m22	El m22.
m23	El m23.
m30	El m30.
m31	El m31.
m32	El m32.
m33	El m33.

Métodos

Método	Descripción
clone()
concatenate(Matrix4 m2)	Concatena las dos matrices
copyFrom(Matrix4 src)
decompose(Vector3 translation, Vector3 scaling, Quaternion rotation)	Descompone la matriz de transformación.
equals(Object obj)
getClass()
getDeterminant()	Obtiene el determinante de la matriz.
getIdentity()	Obtiene la matriz identidad.
hashCode()
inverse()	Invierte esta instancia.
mul(Matrix4 lhs, Matrix4 rhs)	Multiplica las dos matrices
mul(Matrix4 lhs, Vector3 v)	Multiplica la matriz y vector3
mul(Matrix4 lhs, Vector4 v)	Multiplica la matriz y vector4
mul(Matrix4 lhs, double v)	Multiplica la matriz y el valor double
normalize()	Normaliza esta instancia.
notify()
notifyAll()
rotate(Quaternion q)	Crea una matriz de rotación a partir de un cuaternión
rotate(double angle, Vector3 axis)	Crea una matriz de rotación mediante ángulo de rotación y eje
rotateFromEuler(Vector3 eul)	Crea una matriz de rotación a partir de ángulos de Euler
rotateFromEuler(double rx, double ry, double rz)	Crea una matriz de rotación a partir de ángulos de Euler
scale(Vector3 s)	Crea una matriz que escala a lo largo del eje x, el eje y y el eje z.
scale(double s)	Crea una matriz que escala a lo largo del eje x, el eje y y el eje z.
scale(double sx, double sy, double sz)	Crea una matriz que escala a lo largo del eje x, el eje y y el eje z.
setTRS(Vector3 translation, Vector3 rotation, Vector3 scale)	Inicializa la matriz con traslación/rotación/escala
toArray()	Convierte la matriz a un arreglo.
toString()	Devuelve un java.lang.String que representa el Matrix4 actual.
translate(Vector3 t)	Crea una matriz que traslada a lo largo del eje x, el eje y y el eje z
translate(double tx, double ty, double tz)	Crea una matriz que traslada a lo largo del eje x, el eje y y el eje z
transpose()	Transpone esta instancia.
wait()
wait(long arg0)
wait(long arg0, int arg1)

Matrix4(Vector4 r0, Vector4 r1, Vector4 r2, Vector4 r3)

public Matrix4(Vector4 r0, Vector4 r1, Vector4 r2, Vector4 r3)

Construye la matriz a partir de 4 filas.

Parameters:

Parámetro	Tipo	Descripción
r0	Vector4	R0.
r1	Vector4	R1.
r2	Vector4	R2.
r3	Vector4	R3.

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

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

Inicializa una nueva instancia de la estructura Matrix4.

Parameters:

Parámetro	Tipo	Descripción
m00	double	M00.
m01	double	M01.
m02	double	M02.
m03	double	M03.
m10	double	M10.
m11	double	M11.
m12	double	M12.
m13	double	M13.
m20	double	M20.
m21	double	M21.
m22	double	M22.
m23	double	M23.
m30	double	M30.
m31	double	M31.
m32	double	M32.
	m33	double

var mat = new Matrix4(
         1, 0, 0, 0,
         0, 1, 0, 0,
         0, 0, 1, 0,
         10, 20, 0, 1);
     var pos = new Vector3(10, 0, -1);
     var transformed = Matrix4.mul(mat, pos);
``` |

### Matrix4(FMatrix4 m) {#Matrix4-com.aspose.threed.FMatrix4-}

public Matrix4(FMatrix4 m)

Construye [Matrix4](../../com.aspose.threed/matrix4) a partir de una instancia de [FMatrix4](../../com.aspose.threed/fmatrix4).

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| m | [FMatrix4](../../com.aspose.threed/fmatrix4) |  |

### Matrix4(double[] m) {#Matrix4-double---}

public Matrix4(double[] m)

Inicializa una nueva instancia de la estructura [Matrix4](../../com.aspose.threed/matrix4).

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| m | double[] | M. |

### Matrix4() {#Matrix4--}

public Matrix4()

### m00 {#m00}

public double m00

El m00.

### m01 {#m01}

public double m01

El m01.

### m02 {#m02}

public double m02

El m02.

### m03 {#m03}

public double m03

El m03.

### m10 {#m10}

public double m10

El m10.

### m11 {#m11}

public double m11

El m11.

### m12 {#m12}

public double m12

El m12.

### m13 {#m13}

public double m13

El m13.

### m20 {#m20}

public double m20

El m20.

### m21 {#m21}

public double m21

El m21.

### m22 {#m22}

public double m22

El m22.

### m23 {#m23}

public double m23

El m23.

### m30 {#m30}

public double m30

El m30.

### m31 {#m31}

public double m31

El m31.

### m32 {#m32}

public double m32

El m32.

### m33 {#m33}

public double m33

El m33.

### clone() {#clone--}

public Matrix4 clone()

Clonar la instancia actual

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### concatenate(Matrix4 m2) {#concatenate-com.aspose.threed.Matrix4-}

public Matrix4 concatenate(Matrix4 m2)

Concatena las dos matrices

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| m2 | [Matrix4](../../com.aspose.threed/matrix4) | M2. |

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4) - New matrix4 **Example:**

Matrix4 t = Matrix4.translate(0, 10, 9); Matrix4 s = Matrix4.scale(10, 10, 10); Matrix4 transform = t.concatenate(s); Vector3 pos = new Vector3(10, 0, -1); Vector3 transformed = Matrix4.mul(transform, pos);

### copyFrom(Matrix4 src) {#copyFrom-com.aspose.threed.Matrix4-}

public void copyFrom(Matrix4 src)

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| src | [Matrix4](../../com.aspose.threed/matrix4) |  |

### decompose(Vector3 translation, Vector3 scaling, Quaternion rotation) {#decompose-com.aspose.threed.Vector3-com.aspose.threed.Vector3-com.aspose.threed.Quaternion-}

public boolean decompose(Vector3 translation, Vector3 scaling, Quaternion rotation)

Descompone la matriz de transformación.

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| translation | [Vector3](../../com.aspose.threed/vector3) | La traducción. |
| scaling | [Vector3](../../com.aspose.threed/vector3) | El escalado. |
| rotation | [Quaternion](../../com.aspose.threed/quaternion) | La rotación. |

**Returns:**
boolean - Verdadero si tuvo éxito.
### equals(Object obj) {#equals-java.lang.Object-}

public boolean equals(Object obj)

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| obj | java.lang.Object |  |

**Returns:**
boolean
### getClass() {#getClass--}

public final native Class getClass()

**Returns:**
java.lang.Class<?>
### getDeterminant() {#getDeterminant--}

public double getDeterminant()

Obtiene el determinante de la matriz.

**Returns:**
double - el determinante de la matriz.
### getIdentity() {#getIdentity--}

public static Matrix4 getIdentity()

Obtiene la matriz identidad.

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4) - the identity matrix.
### hashCode() {#hashCode--}

public int hashCode()

**Returns:**
int
### inverse() {#inverse--}

public Matrix4 inverse()

Invierte esta instancia.

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4) - Inverse matrix4 **Example:** The following code shows how to inverse a matrix

Matrix4 t = Matrix4.translate(0, 10, 9); Matrix4 mat = t.inverse(); System.out.printf(“Inversed Matrix: %s”, mat);

### mul(Matrix4 lhs, Matrix4 rhs) {#mul-com.aspose.threed.Matrix4-com.aspose.threed.Matrix4-}

public static Matrix4 mul(Matrix4 lhs, Matrix4 rhs)

Multiplica las dos matrices

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| lhs | [Matrix4](../../com.aspose.threed/matrix4) | Lhs. |
| rhs | [Matrix4](../../com.aspose.threed/matrix4) | Rhs. |

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4) - Result matrix
### mul(Matrix4 lhs, Vector3 v) {#mul-com.aspose.threed.Matrix4-com.aspose.threed.Vector3-}

public static Vector3 mul(Matrix4 lhs, Vector3 v)

Multiplica la matriz y vector3

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| lhs | [Matrix4](../../com.aspose.threed/matrix4) | Lhs. |
| v | [Vector3](../../com.aspose.threed/vector3) | V. |

**Returns:**
[Vector3](../../com.aspose.threed/vector3) - Result matrix
### mul(Matrix4 lhs, Vector4 v) {#mul-com.aspose.threed.Matrix4-com.aspose.threed.Vector4-}

public static Vector4 mul(Matrix4 lhs, Vector4 v)

Multiplica la matriz y vector4

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| lhs | [Matrix4](../../com.aspose.threed/matrix4) | Lhs. |
| v | [Vector4](../../com.aspose.threed/vector4) | V. |

**Returns:**
[Vector4](../../com.aspose.threed/vector4) - Result matrix
### mul(Matrix4 lhs, double v) {#mul-com.aspose.threed.Matrix4-double-}

public static Matrix4 mul(Matrix4 lhs, double v)

Multiplica la matriz y el valor double

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| lhs | [Matrix4](../../com.aspose.threed/matrix4) | Lhs. |
| v | double | V. |

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4) - Result matrix
### normalize() {#normalize--}

public Matrix4 normalize()

Normaliza esta instancia.

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4) - Normalize matrix4
### notify() {#notify--}

public final native void notify()

### notifyAll() {#notifyAll--}

public final native void notifyAll()

### rotate(Quaternion q) {#rotate-com.aspose.threed.Quaternion-}

public static Matrix4 rotate(Quaternion q)

Crea una matriz de rotación a partir de un cuaternión

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
|  | q | [Quaternion](../../com.aspose.threed/quaternion) | Cuaternión de rotación **Example:** El siguiente código muestra cómo crear una matriz para la operación de rotación. |

var t = Matrix4.rotate(Quaternion.fromAngleAxis(Math.PI, Vector3.getUnitY())); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### rotate(double angle, Vector3 axis) {#rotate-double-com.aspose.threed.Vector3-}

public static Matrix4 rotate(double angle, Vector3 axis)

Crea una matriz de rotación mediante ángulo de rotación y eje

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| ángulo | double | Ángulo de rotación en radianes |
|  | axis | [Vector3](../../com.aspose.threed/vector3) | Eje de rotación **Example:** El siguiente código muestra cómo crear una matriz para la operación de rotación. |

var t = Matrix4.rotate(Math.PI, new Vector3(0, 1, 0)); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### rotateFromEuler(Vector3 eul) {#rotateFromEuler-com.aspose.threed.Vector3-}

public static Matrix4 rotateFromEuler(Vector3 eul)

Crea una matriz de rotación a partir de ángulos de Euler

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
|  | eul | [Vector3](../../com.aspose.threed/vector3) | Rotación en radianes **Example:** El siguiente código muestra cómo crear una matriz para la operación de rotación. |

var t = Matrix4.rotateFromEuler(new Vector3(0, Math.PI, 0)); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### rotateFromEuler(double rx, double ry, double rz) {#rotateFromEuler-double-double-double-}

public static Matrix4 rotateFromEuler(double rx, double ry, double rz)

Crea una matriz de rotación a partir de ángulos de Euler

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| rx | double | Rotación en el eje x en radianes |
| ry | double | Rotación en el eje y en radianes |
|  | rz | double | Rotación en el eje z en radianes **Example:** El siguiente código muestra cómo crear una matriz para la operación de rotación. |

var t = Matrix4.rotateFromEuler(0, Math.PI, 0); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### scale(Vector3 s) {#scale-com.aspose.threed.Vector3-}

public static Matrix4 scale(Vector3 s)

Crea una matriz que escala a lo largo del eje x, el eje y y el eje z.

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
|  | s | [Vector3](../../com.aspose.threed/vector3) | Los factores de escala se aplican al eje x, al eje y y al eje z **Example:** El siguiente código muestra cómo crear una matriz para la operación de escalado. |

var t = Matrix4.scale(new Vector3(10, 10, 10)); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### scale(double s) {#scale-double-}

public static Matrix4 scale(double s)

Crea una matriz que escala a lo largo del eje x, el eje y y el eje z.

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
|  | s | double | Los factores de escala se aplican a todos los ejes **Example:** El siguiente código muestra cómo crear una matriz para la operación de escalado. |

var t = Matrix4.scale(10); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### scale(double sx, double sy, double sz) {#scale-double-double-double-}

public static Matrix4 scale(double sx, double sy, double sz)

Crea una matriz que escala a lo largo del eje x, el eje y y el eje z.

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| sx | double | Los factores de escala se aplican al eje x |
| sy | double | Los factores de escala se aplican al eje y |
|  | sz | double | Los factores de escala se aplican al eje z **Example:** El siguiente código muestra cómo crear una matriz para la operación de escalado. |

var t = Matrix4.scale(10, 20, 10); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### setTRS(Vector3 translation, Vector3 rotation, Vector3 scale) {#setTRS-com.aspose.threed.Vector3-com.aspose.threed.Vector3-com.aspose.threed.Vector3-}

public void setTRS(Vector3 translation, Vector3 rotation, Vector3 scale)

Inicializa la matriz con traslación/rotación/escala

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| translation | [Vector3](../../com.aspose.threed/vector3) | Traslación. |
| rotation | [Vector3](../../com.aspose.threed/vector3) | Ángulos de Euler para rotación, los campos están en grados. |
| scale | [Vector3](../../com.aspose.threed/vector3) | Escala. |

### toArray() {#toArray--}

public double[] toArray()

Convierte la matriz a un arreglo.

**Returns:**
double[] - El arreglo.
### toString() {#toString--}

public String toString()

Devuelve un java.lang.String que representa el [Matrix4](../../com.aspose.threed/matrix4) actual.

**Returns:**
java.lang.String - Un java.lang.String que representa el [Matrix4](../../com.aspose.threed/matrix4) actual.
### translate(Vector3 t) {#translate-com.aspose.threed.Vector3-}

public static Matrix4 translate(Vector3 t)

Crea una matriz que traslada a lo largo del eje x, el eje y y el eje z

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
|  | t | [Vector3](../../com.aspose.threed/vector3) | Desplazamiento de traducción **Example:** El siguiente código muestra cómo crear una matriz para la operación de traslación. |

Matrix4 t = Matrix4.translate(new Vector3(10, 0, 0)); Vector3 pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### translate(double tx, double ty, double tz) {#translate-double-double-double-}

public static Matrix4 translate(double tx, double ty, double tz)

Crea una matriz que traslada a lo largo del eje x, el eje y y el eje z

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| tx | double | Desplazamiento de la coordenada X |
| ty | double | Desplazamiento de la coordenada Y |
|  | tz | double | Desplazamiento del eje Z **Example:** El siguiente código muestra cómo crear una matriz para la operación de traslación. |

var t = Matrix4.translate(10, 0, 0); var pos = new Vector3(1, 1, 10); System.out.printf(“Transformed: %s”, Matrix4.mul(t, pos));

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4)
### transpose() {#transpose--}

public Matrix4 transpose()

Transpone esta instancia.

**Returns:**
[Matrix4](../../com.aspose.threed/matrix4) - The transposed matrix. **Example:** The following code shows how to transpose a matrix

Matrix4 t = Matrix4.translate(0, 10, 9); Matrix4 mat = t.transpose(); System.out.printf(“Transposed Matrix: %s”, mat);

### wait() {#wait--}

public final void wait()

### wait(long arg0) {#wait-long-}

public final void wait(long arg0)

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| arg0 | long |  |

### wait(long arg0, int arg1) {#wait-long-int-}

public final void wait(long arg0, int arg1)

**Parameters:**
| Parámetro | Tipo | Descripción |
| --- | --- | --- |
| arg0 | long |  |
| arg1 | int |  |