Transform3D

public Transform3D(Basis basis, Vector3 origin);

Constructs a Transform3D from four Vector3 values (also called matrix columns). The first three arguments are the Transform3D.Basis's axes (Basis.X, Basis.Y, and Basis.Z).

public Transform3D(Projection projection);

Constructs a Transform3D from four Vector3 values (also called matrix columns). The first three arguments are the Transform3D.Basis's axes (Basis.X, Basis.Y, and Basis.Z).

public Transform3D(Vector3 column0, Vector3 column1, Vector3 column2, Vector3 origin);

Constructs a Transform3D from four Vector3 values (also called matrix columns). The first three arguments are the Transform3D.Basis's axes (Basis.X, Basis.Y, and Basis.Z).

public Transform3D(float xx, float yx, float zx, float xy, float yy, float zy, float xz, float yz, float zz, float ox, float oy, float oz);

Constructs a Transform3D from four Vector3 values (also called matrix columns). The first three arguments are the Transform3D.Basis's axes (Basis.X, Basis.Y, and Basis.Z).

public static Transform3D FlipX { get; }

Transform3D with mirroring applied perpendicular to the YZ plane. Its Transform3D.Basis is equal to Basis.FlipX.

public static Transform3D FlipY { get; }

Transform3D with mirroring applied perpendicular to the XZ plane. Its Transform3D.Basis is equal to Basis.FlipY.

public static Transform3D FlipZ { get; }

Transform3D with mirroring applied perpendicular to the XY plane. Its Transform3D.Basis is equal to Basis.FlipZ.

public static Transform3D Identity { get; }

The identity Transform3D. This is a transform with no translation, no rotation, and a scale of Vector3.One. Its Transform3D.Basis is equal to Basis.Identity. This also means that:

• Its Basis.X points right (Vector3.Right);
• Its Basis.Y points up (Vector3.Up);
• Its Basis.Z points back (Vector3.Back).

If a Vector3, an Aabb, a Plane, a Vector3[], or another Transform3D is transformed (multiplied) by this constant, no transformation occurs. Note: In C#, this constant is equivalent to creating a [constructor Transform3D] without any arguments. It can be used to make your code clearer, and for consistency with C#.

public Vector3 this[int column] { get; set; }

Access whole columns in the form of Vector3. The fourth column is the Transform3D.Origin vector.

public float this[int column, int row] { get; set; }

Access matrix elements in column-major order. The fourth column is the Transform3D.Origin vector.

public Transform3D AffineInverse();

Inverts Basis and translation, including scale. An exactly zero Basis determinant throws InvalidOperationException. Transform a surface normal with inverse-transposed Basis, without translation.

public bool Equals(Transform3D other);

Returns true if the transforms are exactly equal. Note: Due to floating-point precision errors, consider using Transform3D.IsEqualApprox instead, which is more reliable.

public override bool Equals(object? obj);

Returns true if the transform is exactly equal to the given object (obj). Note: Due to floating-point precision errors, consider using Transform3D.IsEqualApprox instead, which is more reliable.

public override int GetHashCode();

Serves as the hash function for Transform3D.

public Transform3D InterpolateWith(Transform3D transform, float weight);

Returns the result of the linear interpolation between this transform and xform by the given weight. The weight should be between 0.0 and 1.0 (inclusive). Values outside this range are allowed and can be used to perform extrapolation instead.

public Transform3D Inverse();

Uses a transposed Basis and assumes orthonormality. Does not replace AffineInverse under nonuniform scale.

public bool IsEqualApprox(Transform3D other);

Returns true if this transform and xform are approximately equal, by running @GlobalScope.is_equal_approx on each component.

public bool IsFinite();

Returns true if this transform is finite, by calling @GlobalScope.is_finite on each component.

public Transform3D LookingAt(Vector3 target, Vector3 up);

Returns a copy of this transform rotated so that the forward axis (-Z) points towards the target position. The up axis (+Y) points as close to the up vector as possible while staying perpendicular to the forward axis. The resulting transform is orthonormalized. The existing rotation, scale, and skew information from the original transform is discarded. The target and up vectors cannot be zero, cannot be parallel to each other, and are defined in global/parent space. If use_model_front is true, the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the target position. By default, the -Z axis (camera forward) is treated as forward (implies +X is right).

public Transform3D LookingAt(Vector3 target, Vector3? up = default, bool useModelFront = false);

Returns a copy of this transform rotated so that the forward axis (-Z) points towards the target position. The up axis (+Y) points as close to the up vector as possible while staying perpendicular to the forward axis. The resulting transform is orthonormalized. The existing rotation, scale, and skew information from the original transform is discarded. The target and up vectors cannot be zero, cannot be parallel to each other, and are defined in global/parent space. If use_model_front is true, the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the target position. By default, the -Z axis (camera forward) is treated as forward (implies +X is right).

public Transform3D Orthonormalized();

Returns a copy of this transform with its Transform3D.Basis orthonormalized. An orthonormal basis is both orthogonal (the axes are perpendicular to each other) and normalized (the axes have a length of 1.0), which also means it can only represent a rotation. See also Basis.Orthonormalized.

public Transform3D Rotated(Vector3 axis, float angle);

Rotates in external space, including Origin around the external origin. axis must have unit length; angle is in radians. Returns a copy without modifying the original value.

public Transform3D RotatedLocal(Vector3 axis, float angle);

Rotates in the local basis and preserves Origin. axis must have unit length; angle is in radians. Returns a copy without modifying the original value.

public Transform3D Scaled(Vector3 scale);

Returns a copy of this transform scaled by the given scale factor. This method is an optimized version of multiplying the given transform X with a corresponding scaling transform S from the left, i.e., S * X. This can be seen as transforming with respect to the global/parent frame.

public Transform3D ScaledLocal(Vector3 scale);

Returns a copy of this transform scaled by the given scale factor. This method is an optimized version of multiplying the given transform X with a corresponding scaling transform S from the right, i.e., X * S. This can be seen as transforming with respect to the local frame.

public override string ToString();

Converts this Transform3D to a string.

public string ToString(string? format);

Converts this Transform3D to a string with the given format.

public Transform3D Translated(Vector3 offset);

Returns a copy of this transform translated by the given offset. This method is an optimized version of multiplying the given transform X with a corresponding translation transform T from the left, i.e., T * X. This can be seen as transforming with respect to the global/parent frame.

public Transform3D TranslatedLocal(Vector3 offset);

Returns a copy of this transform translated by the given offset. This method is an optimized version of multiplying the given transform X with a corresponding translation transform T from the right, i.e., X * T. This can be seen as transforming with respect to the local frame.

public static bool operator ==(Transform3D left, Transform3D right);

Returns true if the transforms are exactly equal. Note: Due to floating-point precision errors, consider using Transform3D.IsEqualApprox instead, which is more reliable.

public static bool operator !=(Transform3D left, Transform3D right);

Returns true if the transforms are not equal. Note: Due to floating-point precision errors, consider using Transform3D.IsEqualApprox instead, which is more reliable.

public static Aabb operator *(Aabb aabb, Transform3D transform);

Returns an AABB transformed (multiplied) by the inverse transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not). aabb * transform is equivalent to transform.Inverse() * aabb. See Transform3D.Inverse. For transforming by inverse of an affine transformation (e.g. with scaling) transform.AffineInverse() * aabb can be used instead. See Transform3D.AffineInverse.

public static Plane operator *(Plane plane, Transform3D transform);

Returns a Plane transformed (multiplied) by the inverse transformation matrix. plane * transform is equivalent to transform.AffineInverse() * plane. See Transform3D.AffineInverse.

public static Aabb operator *(Transform3D transform, Aabb aabb);

Returns an AABB transformed (multiplied) by the transformation matrix.

public static Plane operator *(Transform3D transform, Plane plane);

Returns a Plane transformed (multiplied) by the transformation matrix.

public static Transform3D operator *(Transform3D left, Transform3D right);

Composes these two transformation matrices by multiplying them together. This has the effect of transforming the second transform (the child) by the first transform (the parent).

public static Vector3 operator *(Transform3D transform, Vector3 vector);

Returns a Vector3 transformed (multiplied) by the transformation matrix.

public static Vector3[] operator *(Transform3D transform, Vector3[] array);

Returns a copy of the given Vector3[] transformed (multiplied) by the transformation matrix.

public static Vector3 operator *(Vector3 vector, Transform3D transform);

Returns a Vector3 transformed (multiplied) by the inverse transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not). vector * transform is equivalent to transform.Inverse() * vector. See Transform3D.Inverse. For transforming by inverse of an affine transformation (e.g. with scaling) transform.AffineInverse() * vector can be used instead. See Transform3D.AffineInverse.

public static Vector3[] operator *(Vector3[] array, Transform3D transform);

Returns a copy of the given Vector3[] transformed (multiplied) by the inverse transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not). array * transform is equivalent to transform.Inverse() * array. See Transform3D.Inverse. For transforming by inverse of an affine transformation (e.g. with scaling) transform.AffineInverse() * array can be used instead. See Transform3D.AffineInverse.

public Basis Basis;

The Basis of this transform. It is composed by 3 axes (Basis.X, Basis.Y, and Basis.Z). Together, these represent the transform's rotation, scale, and shear.

public Vector3 Origin;

The translation offset of this transform. In 3D space, this can be seen as the position.