Transform2D

public Transform2D(Vector2 xAxis, Vector2 yAxis, Vector2 originPos);

Creates a transform from two basis columns and a translation. xAxis and yAxis are columns, not matrix rows.

public Transform2D(float rotation, Vector2 origin);

Creates a transform from a rotation in radians and a translation. The basis has unit scale and no skew; positive rotation turns Right toward Down in ordinary 2D.

public Transform2D(float rotation, Vector2 scale, float skew, Vector2 origin);

Creates a transform from rotation, scale, skew and translation. Rotation and skew are in radians; zero scale can make the basis noninvertible.

public Transform2D(float xx, float xy, float yx, float yy, float ox, float oy);

Constructs a Transform2D from 3 Vector2 values representing Transform2D.X, Transform2D.Y, and the Transform2D.Origin (the three matrix columns).

public static Transform2D FlipX { get; }

When any transform is multiplied by Transform2D.FlipX, it negates all components of the Transform2D.X axis (the X column). When Transform2D.FlipX is multiplied by any transform, it negates the Vector2.X component of all axes (the X row).

public static Transform2D FlipY { get; }

When any transform is multiplied by Transform2D.FlipY, it negates all components of the Transform2D.Y axis (the Y column). When Transform2D.FlipY is multiplied by any transform, it negates the Vector2.Y component of all axes (the Y row).

public static Transform2D Identity { get; }

Identity transform without translation, rotation or scale change. In C#, parameterless new Transform2D() contains zeros and is not a substitute for Identity.

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

Access whole columns in the form of Vector2. The third column is the Transform2D.Origin vector.

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

Access matrix elements in column-major order. The third column is the Transform2D.Origin vector.

public float Rotation { get; }

Returns the transform's rotation (in radians).

public Vector2 Scale { get; }

Returns the scale.

public float Skew { get; }

Returns the transform's skew (in radians).

public Transform2D AffineInverse();

Returns an affine inverse including scale. The determinant must be nonzero; an exactly zero determinant throws InvalidOperationException.

public Vector2 BasisXform(Vector2 v);

Transforms a vector by the basis without Origin translation. Scale and skew still apply; normalize separately when a unit direction is required.

public Vector2 BasisXformInv(Vector2 v);

Applies the transposed basis without translation. This is an inverse only for an orthonormal basis; with scale or skew use AffineInverse().BasisXform(v).

public float Determinant();

Returns the basis determinant X.X * Y.Y - X.Y * Y.X. Zero means noninvertible, a negative value reverses orientation; translation does not affect the result.

public bool Equals(Transform2D other);

Returns true if the transforms are exactly equal. Note: Due to floating-point precision errors, consider using Transform2D.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 Transform2D.IsEqualApprox instead, which is more reliable.

public override int GetHashCode();

Serves as the hash function for Transform2D.

public Transform2D InterpolateWith(Transform2D 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 Transform2D Inverse();

Fast inverse for orthonormal axes. Use AffineInverse for invertible scale.

public bool IsEqualApprox(Transform2D 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 Transform2D Orthonormalized();

Returns a copy of this transform with its 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.

public Transform2D Rotated(float angle);

Returns a copy of this transform rotated by the given angle (in radians). If angle is positive, the transform is rotated clockwise. This method is an optimized version of multiplying the given transform X with a corresponding rotation transform R from the left, i.e., R * X. This can be seen as transforming with respect to the global/parent frame.

public Transform2D RotatedLocal(float angle);

Returns a copy of the transform rotated by the given angle (in radians). This method is an optimized version of multiplying the given transform X with a corresponding rotation transform R from the right, i.e., X * R. This can be seen as transforming with respect to the local frame.

public Transform2D Scaled(Vector2 scale);

Returns a copy of the 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 Transform2D ScaledLocal(Vector2 scale);

Returns a copy of the 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 Transform2D to a string.

public string ToString(string? format);

Converts this Transform2D to a string with the given format.

public Transform2D Translated(Vector2 offset);

Returns a copy of the 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 Transform2D TranslatedLocal(Vector2 offset);

Returns a copy of the 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 ==(Transform2D left, Transform2D right);

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

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

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

public static Rect2 operator *(Rect2 rect, Transform2D transform);

Returns a Rect2 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). rect * transform is equivalent to transform.Inverse() * rect. See Transform2D.Inverse. For transforming by inverse of an affine transformation (e.g. with scaling) transform.AffineInverse() * rect can be used instead. See Transform2D.AffineInverse.

public static Rect2 operator *(Transform2D transform, Rect2 rect);

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

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

Composes transforms: left * right applies right first, then left. For a hierarchy this is the parent transform multiplied by the child transform.

public static Vector2 operator *(Transform2D transform, Vector2 vector);

Transforms a point by the basis and adds Origin. For a direction without translation use BasisXform.

public static Vector2[] operator *(Transform2D transform, Vector2[] array);

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

public static Vector2 operator *(Vector2 vector, Transform2D transform);

Inverse-transforms a point assuming an orthonormal basis. With scale or skew this operand order does not replace transform.AffineInverse() * vector.

public static Vector2[] operator *(Vector2[] array, Transform2D transform);

Returns a copy of the given Vector2[] 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 Transform2D.Inverse. For transforming by inverse of an affine transformation (e.g. with scaling) transform.AffineInverse() * array can be used instead. See Transform2D.AffineInverse.

public Vector2 Origin;

Translation applied when transforming a point. BasisXform applies only the basis and does not add Origin.

public Vector2 X;

First basis column: the transformed local X axis. Does not include Origin translation.

public Vector2 Y;

Second basis column: the transformed local Y axis. In ordinary 2D coordinates positive Y points down.