Transform

Transform — Aspose.3D FOSS for Java

Methods: com.aspose.threed (aspose-3d-foss)

Transform contrôle la position, l’orientation et l’échelle d’un Node dans la scène 3D. Chaque nœud possède exactement un Transform, accessible via node.getTransform().

public class Transform extends A3DObject

Accéder au Transform d’un nœud

import com.aspose.threed.Scene;

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("box");
Transform t = node.getTransform();

Methods

Methods	Methods	Methods	Methods	Methods
`translation`	`Vector3`	`getTranslation()`	`setTranslation(Vector3)`	Décalage de position par rapport à l’origine du nœud parent. Par défaut `Vector3(0, 0, 0)`.
`scaling`	`Vector3`	`getScaling()`	`setScaling(Vector3)`	Facteur d’échelle non uniforme par axe. Par défaut `Vector3(1, 1, 1)`.
`rotation`	`Quaternion`	`getRotation()`	`setRotation(Quaternion)`	Rotation sous forme de quaternion unitaire. Modifier cela met également à jour les angles d’Euler.
`eulerAngles`	`Vector3`	`getEulerAngles()`	`setEulerAngles(Vector3)`	Rotation en degrés sous forme d’angles d’Euler (X, Y, Z). Modifier cela met également à jour la rotation quaternion.
`preRotation`	`Vector3`	`getPreRotation()`	`setPreRotation(Vector3)`	Angles d’Euler appliqués avant la rotation principale (utilisés dans les rigs FBX).
`postRotation`	`Vector3`	`getPostRotation()`	`setPostRotation(Vector3)`	Angles d’Euler appliqués après la rotation principale.
`geometricTranslation`	`Vector3`	`getGeometricTranslation()`	`setGeometricTranslation(Vector3)`	Translation locale uniquement : affecte la géométrie mais pas les nœuds enfants.
`geometricScaling`	`Vector3`	`getGeometricScaling()`	`setGeometricScaling(Vector3)`	Échelle locale uniquement : affecte la géométrie mais pas les nœuds enfants.
`geometricRotation`	`Vector3`	`getGeometricRotation()`	`setGeometricRotation(Vector3)`	Rotation locale uniquement : affecte la géométrie mais pas les nœuds enfants.
`transformMatrix`	`Matrix4`	`getTransformMatrix()`	`setTransformMatrix(Matrix4)`	La matrice de transformation 4x4 complète combinée. En cache ; recomputée lorsque n’importe quel composant change. La définir la décompose de nouveau en translation/scaling/rotation.

Méthodes d’assignation fluide

Tous les setters renvoient this, permettant le chaînage :

Methods	Methods	Methods
`setTranslation(double tx, double ty, double tz)`	`double, double, double`	Définir la position.
`setScale(double sx, double sy, double sz)`	`double, double, double`	Définir l’échelle.
`setEulerAngles(double rx, double ry, double rz)`	`double, double, double`	Définir la rotation en degrés.
`setRotation(double rx, double ry, double rz, double rw)`	`double, double, double, double`	Définir la rotation sous forme de quaternion (x, y, z, w).
`setPreRotation(double rx, double ry, double rz)`	`double, double, double`	Définir la pré-rotation en degrés.
`setPostRotation(double rx, double ry, double rz)`	`double, double, double`	Définir la post-rotation en degrés.
`setGeometricTranslation(double x, double y, double z)`	`double, double, double`	Définir la translation géométrique.
`setGeometricScaling(double sx, double sy, double sz)`	`double, double, double`	Définir l’échelle géométrique.
`setGeometricRotation(double rx, double ry, double rz)`	`double, double, double`	Définir la rotation géométrique en degrés.

Exemples d’utilisation

Positionner un nœud

import com.aspose.threed.Scene;
import com.aspose.threed.*;

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("box");

// Using fluent setters
node.getTransform().setTranslation(5.0, 0.0, -3.0);

// Or via property setter
node.getTransform().setTranslation(new Vector3(5.0, 0.0, -3.0));

Faire pivoter avec des angles d’Euler

import com.aspose.threed.Scene;

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("rotated");

// Rotate 45 degrees around Y axis
node.getTransform().setEulerAngles(0.0, 45.0, 0.0);

// Chain multiple operations
node.getTransform()
    .setTranslation(2.0, 0.0, 0.0)
    .setScale(2.0, 2.0, 2.0);

Faire pivoter avec un Quaternion

import com.aspose.threed.Scene;
import com.aspose.threed.*;
import com.aspose.threed.*;

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("q-rotated");

// 90 degrees rotation around the Y axis
double halfAngle = Math.toRadians(45);   // half the total rotation
Quaternion q = new Quaternion(Math.cos(halfAngle), 0.0, Math.sin(halfAngle), 0.0);
node.getTransform().setRotation(q);

System.out.println("Euler: " + node.getTransform().getEulerAngles());   // synced automatically

Mise à l’échelle et position simultanées

import com.aspose.threed.Scene;

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("big-offset");

node.getTransform()
    .setTranslation(10.0, 0.0, 0.0)
    .setScale(3.0, 3.0, 3.0)
    .setEulerAngles(0.0, 90.0, 0.0);

Décalage géométrique (décalage du pivot)

Les transformations géométriques déplacent la géométrie par rapport au pivot du nœud sans affecter les nœuds enfants ; utiles pour centrer un maillage dans son nœud :

import com.aspose.threed.Scene;

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("centered-mesh");

// Shift the mesh half a unit down so its base sits at y=0
node.getTransform().setGeometricTranslation(0.0, -0.5, 0.0);

Lire la matrice de transformation combinée

import com.aspose.threed.Scene;
import com.aspose.threed.*;

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("m");
node.getTransform().setTranslation(1.0, 2.0, 3.0);
node.getTransform().setEulerAngles(0.0, 45.0, 0.0);

Matrix4 m = node.getTransform().getTransformMatrix();
System.out.println(m.getClass().getName());   // com.aspose.threed.Matrix4