Matrix4

Inheritance: java.lang.Object

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

public final class Matrix4 implements Struct<Matrix4>, Serializable

Implementazione di matrice 4x4. Esempio:

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

Costruttori

Costruttore	Descrizione
Matrix4(Vector4 r0, Vector4 r1, Vector4 r2, Vector4 r3)	Costruisce la matrice da 4 righe.
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)	Inizializza una nuova istanza della struttura Matrix4.
Matrix4(FMatrix4 m)	Costruisci Matrix4 da un’istanza di FMatrix4.
Matrix4(double[] m)	Inizializza una nuova istanza della struttura Matrix4.
Matrix4()

Campi

Campo	Descrizione
m00	Il m00.
m01	Il m01.
m02	Il m02.
m03	Il m03.
m10	Il m10.
m11	Il m11.
m12	Il m12.
m13	Il m13.
m20	Il m20.
m21	Il m21.
m22	Il m22.
m23	Il m23.
m30	Il m30.
m31	Il m31.
m32	Il m32.
m33	Il m33.

Metodi

Metodo	Descrizione
clone()
concatenate(Matrix4 m2)	Concatena le due matrici
copyFrom(Matrix4 src)
decompose(Vector3 translation, Vector3 scaling, Quaternion rotation)	Decompone la matrice di trasformazione.
equals(Object obj)
getClass()
getDeterminant()	Restituisce il determinante della matrice.
getIdentity()	Restituisce la matrice identità.
hashCode()
inverse()	Inverte questa istanza.
mul(Matrix4 lhs, Matrix4 rhs)	Moltiplica le due matrici
mul(Matrix4 lhs, Vector3 v)	Moltiplica la matrice e il vector3
mul(Matrix4 lhs, Vector4 v)	Moltiplica la matrice e il vector4
mul(Matrix4 lhs, double v)	Moltiplica la matrice per un valore double
normalize()	Normalizza questa istanza.
notify()
notifyAll()
rotate(Quaternion q)	Crea una matrice di rotazione da un quaternion
rotate(double angle, Vector3 axis)	Crea una matrice di rotazione per angolo di rotazione e asse
rotateFromEuler(Vector3 eul)	Crea una matrice di rotazione da un angolo di Eulero
rotateFromEuler(double rx, double ry, double rz)	Crea una matrice di rotazione da un angolo di Eulero
scale(Vector3 s)	Crea una matrice che scala lungo l’asse x, l’asse y e l’asse z.
scale(double s)	Crea una matrice che scala lungo l’asse x, l’asse y e l’asse z.
scale(double sx, double sy, double sz)	Crea una matrice che scala lungo l’asse x, l’asse y e l’asse z.
setTRS(Vector3 translation, Vector3 rotation, Vector3 scale)	Inizializza la matrice con traslazione/rotazione/scalatura
toArray()	Converte la matrice in un array.
toString()	Restituisce una java.lang.String che rappresenta l’attuale Matrix4.
translate(Vector3 t)	Crea una matrice che trasla lungo l’asse x, l’asse y e l’asse z
translate(double tx, double ty, double tz)	Crea una matrice che trasla lungo l’asse x, l’asse y e l’asse z
transpose()	Trasponi questa istanza.
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)

Costruisce la matrice da 4 righe.

Parameters:

Parametro	Tipo	Descrizione
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)

Inizializza una nuova istanza della struttura Matrix4.

Parameters:

Parametro	Tipo	Descrizione
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)

Costruisci [Matrix4](../../com.aspose.threed/matrix4) da un'istanza di [FMatrix4](../../com.aspose.threed/fmatrix4).

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| m | [FMatrix4](../../com.aspose.threed/fmatrix4) |  |

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

public Matrix4(double[] m)

Inizializza una nuova istanza della struttura [Matrix4](../../com.aspose.threed/matrix4).

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| m | double[] | M. |

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

public Matrix4()

### m00 {#m00}

public double m00

Il m00.

### m01 {#m01}

public double m01

Il m01.

### m02 {#m02}

public double m02

Il m02.

### m03 {#m03}

public double m03

Il m03.

### m10 {#m10}

public double m10

Il m10.

### m11 {#m11}

public double m11

Il m11.

### m12 {#m12}

public double m12

Il m12.

### m13 {#m13}

public double m13

Il m13.

### m20 {#m20}

public double m20

Il m20.

### m21 {#m21}

public double m21

Il m21.

### m22 {#m22}

public double m22

Il m22.

### m23 {#m23}

public double m23

Il m23.

### m30 {#m30}

public double m30

Il m30.

### m31 {#m31}

public double m31

Il m31.

### m32 {#m32}

public double m32

Il m32.

### m33 {#m33}

public double m33

Il m33.

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

public Matrix4 clone()

Clona l'istanza corrente

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

public Matrix4 concatenate(Matrix4 m2)

Concatena le due matrici

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| 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:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| 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)

Decompone la matrice di trasformazione.

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| translation | [Vector3](../../com.aspose.threed/vector3) | La traduzione. |
| scaling | [Vector3](../../com.aspose.threed/vector3) | La scalatura. |
| rotation | [Quaternion](../../com.aspose.threed/quaternion) | La rotazione. |

**Returns:**
boolean - True se ha avuto successo.
### equals(Object obj) {#equals-java.lang.Object-}

public boolean equals(Object obj)

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| obj | java.lang.Object |  |

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

public final native Class getClass()

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

public double getDeterminant()

Restituisce il determinante della matrice.

**Returns:**
double - il determinante della matrice.
### getIdentity() {#getIdentity--}

public static Matrix4 getIdentity()

Restituisce la matrice identità.

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

public int hashCode()

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

public Matrix4 inverse()

Inverte questa istanza.

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

Moltiplica le due matrici

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| 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)

Moltiplica la matrice e il vector3

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| 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)

Moltiplica la matrice e il vector4

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| 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)

Moltiplica la matrice per un valore double

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| lhs | [Matrix4](../../com.aspose.threed/matrix4) | Lhs. |
| v | double | V. |

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

public Matrix4 normalize()

Normalizza questa istanza.

**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 matrice di rotazione da un quaternion

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
|  | q | [Quaternion](../../com.aspose.threed/quaternion) | Quaternione di rotazione **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di rotazione. |

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 matrice di rotazione per angolo di rotazione e asse

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| angolo | double | Angolo di rotazione in radianti |
|  | axis | [Vector3](../../com.aspose.threed/vector3) | Asse di rotazione **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di rotazione. |

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 matrice di rotazione da un angolo di Eulero

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
|  | eul | [Vector3](../../com.aspose.threed/vector3) | Rotazione in radianti **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di rotazione. |

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 matrice di rotazione da un angolo di Eulero

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| rx | double | Rotazione sull'asse x in radianti |
| ry | double | Rotazione sull'asse y in radianti |
|  | rz | double | Rotazione sull'asse z in radianti **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di rotazione. |

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 matrice che scala lungo l'asse x, l'asse y e l'asse z.

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
|  | s | [Vector3](../../com.aspose.threed/vector3) | Le fabbriche di scaling si applicano all'asse x, all'asse y e all'asse z **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di scaling. |

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 matrice che scala lungo l'asse x, l'asse y e l'asse z.

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
|  | s | double | Le fabbriche di scaling si applicano a tutti gli assi **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di scaling. |

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 matrice che scala lungo l'asse x, l'asse y e l'asse z.

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| sx | double | Le fabbriche di scaling si applicano all'asse x |
| sy | double | Le fabbriche di scaling si applicano all'asse y |
|  | sz | double | Le fabbriche di scaling si applicano all'asse z **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di scaling. |

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)

Inizializza la matrice con traslazione/rotazione/scalatura

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| translation | [Vector3](../../com.aspose.threed/vector3) | Traduzione. |
| rotation | [Vector3](../../com.aspose.threed/vector3) | Angoli di Eulero per la rotazione, i campi sono in gradi. |
| scale | [Vector3](../../com.aspose.threed/vector3) | Scala. |

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

public double[] toArray()

Converte la matrice in un array.

**Returns:**
double[] - L'array.
### toString() {#toString--}

public String toString()

Restituisce una java.lang.String che rappresenta l'attuale [Matrix4](../../com.aspose.threed/matrix4).

**Returns:**
java.lang.String - Una java.lang.String che rappresenta l'attuale [Matrix4](../../com.aspose.threed/matrix4).
### translate(Vector3 t) {#translate-com.aspose.threed.Vector3-}

public static Matrix4 translate(Vector3 t)

Crea una matrice che trasla lungo l'asse x, l'asse y e l'asse z

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
|  | t | [Vector3](../../com.aspose.threed/vector3) | Offset di traslazione **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di traslazione. |

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 matrice che trasla lungo l'asse x, l'asse y e l'asse z

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| tx | double | Offset della coordinata X |
| ty | double | Offset della coordinata Y |
|  | tz | double | Offset della coordinata Z **Esempio:** Il codice seguente mostra come creare una matrice per l'operazione di traslazione. |

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()

Trasponi questa istanza.

**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:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| arg0 | long |  |

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

public final void wait(long arg0, int arg1)

**Parameters:**
| Parametro | Tipo | Descrizione |
| --- | --- | --- |
| arg0 | long |  |
| arg1 | int |  |