sprunk-engine
    Preparing search index...

    3D Transformations in the Game Engine

    A 3D transformation is a mathematical operation that changes the position, rotation, or scale of an object in a 3D space. It allows you to move, rotate, or resize objects relative to their current state or the world space.

    The game engine uses a combination of position, rotation, and scale to define the transformation of an object. These properties are represented using:

    • Position: A Vector3 object defining the object's location in 3D space.
    • Rotation: A Quaternion object defining the object's orientation.
    • Scale: A Vector3 object defining the object's size along the X, Y, and Z axes.

    These transformations are applied hierarchically, meaning child objects inherit the transformations of their parent objects.

    Keep in mind that position, rotation and scale are readonly in the transform so the reference cannot change! This implies that you will be using in-place changing methods like .set or .rotateAroundAxis

    Right-handed coordinate system

    You can set the position of an object using the position property of its Transform component. For example:

    gameObject.transform.position.set(1, 2, 3); // Moves the object to (1, 2, 3)
    • Local Position: The position of an object relative to its parent. If the object has no parent, this is the same as the world position.
    • World Position: The position of an object in the global 3D space, taking into account the transformations of all its parent objects.

    You can access the world position using the worldPosition property:

    const worldPos = gameObject.transform.worldPosition;

    A quaternion is a mathematical structure used to represent 3D rotations. It avoids issues like gimbal lock and provides smooth interpolation between rotations. Quaternions are more efficient and stable for 3D rotations compared to Euler angles.

    You can rotate an object using the rotation property of its Transform component. For example:

    gameObject.transform.rotation.setFromEulerAngles(0, Math.PI / 2, 0); // Rotates 90 degrees around the Y-axis

    Use the rotateAroundAxis method to rotate an object around a specific axis:

    const axis = new Vector3(1, 0, 0); // X-axis
    const angle = Math.PI / 4; // 45 degrees in radians
    gameObject.transform.rotation.rotateAroundAxis(axis, angle);

    You can combine rotations by multiplying quaternions:

    const rotation1 = Quaternion.fromEulerAngles(0, Math.PI / 2, 0); // 90° around Y-axis
    const rotation2 = Quaternion.fromEulerAngles(Math.PI / 2, 0, 0); // 90° around X-axis
    gameObject.transform.rotation = rotation1.multiply(rotation2);

    You can scale an object using the scale property of its Transform component:

    gameObject.transform.scale.set(2, 1, 1); // Scales the object to twice its size along the X-axis

    World scale is the effective scale of an object in the global 3D space, considering the scales of all its parent objects. You can access it using the worldScale property:

    const worldScale = gameObject.transform.worldScale;

    When an object is a child of another object, its transformations are relative to its parent. For example:

    • If the parent is moved, the child moves with it.
    • If the parent is rotated, the child rotates around the parent's origin.
    • If the parent is scaled, the child is scaled accordingly.

    The world position of a child object is calculated by applying the parent's transformations to the child's local position. For example:

    const childWorldPosition = childObject.transform.worldPosition;
    • To convert Euler angles to a quaternion:
      const quaternion = Quaternion.fromEulerAngles(pitch, yaw, roll);
    • To convert a quaternion to Euler angles:
      const eulerAngles = quaternion.toEulerAngles();

    Use the lerp method to interpolate between two quaternions:

    const interpolatedRotation = Quaternion.identity().lerp(startRotation, endRotation, t);

    Here, t is a value between 0 and 1 representing the interpolation factor.

    Non-uniform scaling (scaling differently along each axis) is supported. However, it can affect rotations and other transformations. Ensure that your object's local coordinate system aligns with the intended scaling behavior.

    • Ensure you are using quaternions for rotations, as Euler angles can lead to gimbal lock.
    • Check if the object is a child of another object, as parent rotations affect child objects.
    • Check the eulerangle application order (by default it is ZXY)

    Scaling can distort the local coordinate system of an object, affecting its rotation. To avoid this, ensure that scaling is applied uniformly or adjust the object's pivot point.

    To reset an object's transformations:

    gameObject.transform.position.set(0, 0, 0);
    gameObject.transform.rotation.setFromQuaternion(Quaternion.identity());
    gameObject.transform.scale.set(1, 1, 1);

    Settings

    Member Visibility

    On This Page

    3D Transformations in the Game Engine