From 891703e43e6409fdb625333e94037f385a151e39 Mon Sep 17 00:00:00 2001 From: Micky Date: Mon, 8 Jul 2024 13:29:51 +0200 Subject: [PATCH] Overhaul Transform2D documentation --- doc/classes/Transform2D.xml | 133 +++++++++++++++++++++++++----------- 1 file changed, 92 insertions(+), 41 deletions(-) diff --git a/doc/classes/Transform2D.xml b/doc/classes/Transform2D.xml index 345d0512ffb..4158fbe710d 100644 --- a/doc/classes/Transform2D.xml +++ b/doc/classes/Transform2D.xml @@ -4,8 +4,10 @@ A 2×3 matrix representing a 2D transformation. - A 2×3 matrix (2 rows, 3 columns) used for 2D linear transformations. It can represent transformations such as translation, rotation, and scaling. It consists of three [Vector2] values: [member x], [member y], and the [member origin]. + The [Transform2D] built-in [Variant] type is a 2×3 [url=https://en.wikipedia.org/wiki/Matrix_(mathematics)]matrix[/url] representing a transformation in 2D space. It contains three [Vector2] values: [member x], [member y], and [member origin]. Together, they can represent translation, rotation, scale, and skew. + The [member x] and [member y] axes form a 2×2 matrix, known as the transform's [b]basis[/b]. The length of each axis ([method Vector2.length]) influences the transform's scale, while the direction of all axes influence the rotation. Usually, both axes are perpendicular to one another. However, when you rotate one axis individually, the transform becomes skewed. Applying a skewed transform to a 2D sprite will make the sprite appear distorted. For a general introduction, see the [url=$DOCS_URL/tutorials/math/matrices_and_transforms.html]Matrices and transforms[/url] tutorial. + [b]Note:[/b] Unlike [Transform3D], there is no 2D equivalent to the [Basis] type. All mentions of "basis" refer to the [member x] and [member y] components of [Transform2D]. $DOCS_URL/tutorials/math/index.html @@ -17,7 +19,7 @@ - Constructs a default-initialized [Transform2D] set to [constant IDENTITY]. + Constructs a [Transform2D] identical to [constant IDENTITY]. @@ -32,7 +34,7 @@ - Constructs the transform from a given angle (in radians) and position. + Constructs a [Transform2D] from a given angle (in radians) and position. @@ -42,7 +44,7 @@ - Constructs the transform from a given angle (in radians), scale, skew (in radians) and position. + Constructs a [Transform2D] from a given angle (in radians), scale, skew (in radians), and position. @@ -51,7 +53,7 @@ - Constructs the transform from 3 [Vector2] values representing [member x], [member y], and the [member origin] (the three column vectors). + Constructs a [Transform2D] from 3 [Vector2] values representing [member x], [member y], and the [member origin] (the three matrix columns). @@ -59,56 +61,81 @@ - Returns the inverse of the transform, under the assumption that the basis is invertible (must have non-zero determinant). + Returns the inverted version of this transform. Unlike [method inverse], this method works with almost any basis, including non-uniform ones, but is slower. See also [method inverse]. + [b]Note:[/b] For this method to return correctly, the transform's basis needs to have a determinant that is not exactly [code]0[/code] (see [method determinant]). - Returns a vector transformed (multiplied) by the basis matrix. - This method does not account for translation (the [member origin] vector). + Returns a copy of the [param v] vector, transformed (multiplied) by the transform basis's matrix. Unlike the multiplication operator ([code]*[/code]), this method ignores the [member origin]. - Returns a vector transformed (multiplied) by the inverse basis matrix, under the assumption that the basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not). - This method does not account for translation (the [member origin] vector). - [code]transform.basis_xform_inv(vector)[/code] is equivalent to [code]transform.inverse().basis_xform(vector)[/code]. See [method inverse]. - For non-orthonormal transforms (e.g. with scaling) [code]transform.affine_inverse().basis_xform(vector)[/code] can be used instead. See [method affine_inverse]. + Returns a copy of the [param v] vector, transformed (multiplied) by the inverse transform basis's matrix (see [method inverse]). This method ignores the [member origin]. + [b]Note:[/b] This method assumes that this transform's basis is [i]orthonormal[/i] (see [method orthonormalized]). If the basis is not orthonormal, [code]transform.affine_inverse().basis_xform(vector)[/code] should be used instead (see [method affine_inverse]). - Returns the determinant of the basis matrix. If the basis is uniformly scaled, then its determinant equals the square of the scale factor. - A negative determinant means the basis was flipped, so one part of the scale is negative. A zero determinant means the basis isn't invertible, and is usually considered invalid. + Returns the [url=https://en.wikipedia.org/wiki/Determinant]determinant[/url] of this transform basis's matrix. For advanced math, this number can be used to determine a few attributes: + - If the determinant is exactly [code]0[/code], the basis is not invertible (see [method inverse]). + - If the determinant is a negative number, the basis represents a negative scale. + [b]Note:[/b] If the basis's scale is the same for every axis, its determinant is always that scale by the power of 2. - Returns the transform's origin (translation). + Returns this transform's translation. Equivalent to [member origin]. - Returns the transform's rotation (in radians). + Returns this transform's rotation (in radians). This is equivalent to [member x]'s angle (see [method Vector2.angle]). - Returns the scale. + Returns the length of both [member x] and [member y], as a [Vector2]. If this transform's basis is not skewed, this value is the scaling factor. It is not affected by rotation. + [codeblocks] + [gdscript] + var my_transform = Transform2D( + Vector2(2, 0), + Vector2(0, 4), + Vector2(0, 0) + ) + # Rotating the Transform2D in any way preserves its scale. + my_transform = my_transform.rotated(TAU / 2) + + print(my_transform.get_scale()) # Prints (2, 4). + [/gdscript] + [csharp] + var myTransform = new Transform2D( + Vector3(2.0f, 0.0f), + Vector3(0.0f, 4.0f), + Vector3(0.0f, 0.0f) + ); + // Rotating the Transform2D in any way preserves its scale. + myTransform = myTransform.Rotated(Mathf.Tau / 2.0f); + + GD.Print(myTransform.GetScale()); // Prints (2, 4, 8). + [/csharp] + [/codeblocks] + [b]Note:[/b] If the value returned by [method determinant] is negative, the scale is also negative. - Returns the transform's skew (in radians). + Returns this transform's skew (in radians). @@ -116,19 +143,21 @@ - Returns a transform interpolated between this transform and another by a given [param weight] (on the range of 0.0 to 1.0). + Returns the result of the linear interpolation between this transform and [param xform] by the given [param weight]. + The [param weight] should be between [code]0.0[/code] and [code]1.0[/code] (inclusive). Values outside this range are allowed and can be used to perform [i]extrapolation[/i] instead. - Returns the inverse of the transform, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not). Use [method affine_inverse] for non-orthonormal transforms (e.g. with scaling). + Returns the [url=https://en.wikipedia.org/wiki/Invertible_matrix]inverted version of this transform[/url]. + [b]Note:[/b] For this method to return correctly, the transform's basis needs to be [i]orthonormal[/i] (see [method orthonormalized]). That means, the basis should only represent a rotation. If it does not, use [method affine_inverse] instead. - Returns [code]true[/code] if the transform's basis is conformal, meaning it preserves angles and distance ratios, and may only be composed of rotation and uniform scale. Returns [code]false[/code] if the transform's basis has non-uniform scale or shear/skew. This can be used to validate if the transform is non-distorted, which is important for physics and other use cases. + Returns [code]true[/code] if this transform's basis is conformal. A conformal basis is both [i]orthogonal[/i] (the axes are perpendicular to each other) and [i]uniform[/i] (the axes share the same length). This method can be especially useful during physics calculations. @@ -148,14 +177,13 @@ - Returns a copy of the transform rotated such that the rotated X-axis points towards the [param target] position. - Operations take place in global space. + Returns a copy of the transform rotated such that the rotated X-axis points towards the [param target] position, in global space. - Returns the transform with the basis orthogonal (90 degrees), and normalized axis vectors (scale of 1 or -1). + Returns a copy of this transform with its basis orthonormalized. An orthonormal basis is both [i]orthogonal[/i] (the axes are perpendicular to each other) and [i]normalized[/i] (the axes have a length of [code]1[/code]), which also means it can only represent rotation. @@ -215,24 +243,41 @@ - The origin vector (column 2, the third column). Equivalent to array index [code]2[/code]. The origin vector represents translation. + The translation offset of this transform, and the column [code]2[/code] of the matrix. In 2D space, this can be seen as the position. - The basis matrix's X vector (column 0). Equivalent to array index [code]0[/code]. + The transform basis's X axis, and the column [code]0[/code] of the matrix. Combined with [member y], this represents the transform's rotation, scale, and skew. + On the identity transform, this vector points right ([constant Vector2.RIGHT]). - The basis matrix's Y vector (column 1). Equivalent to array index [code]1[/code]. + The transform basis's Y axis, and the column [code]1[/code] of the matrix. Combined with [member x], this represents the transform's rotation, scale, and skew. + On the identity transform, this vector points up ([constant Vector2.UP]). - The identity [Transform2D] with no translation, rotation or scaling applied. When applied to other data structures, [constant IDENTITY] performs no transformation. + The identity [Transform2D]. A transform with no translation, no rotation, and its scale being [code]1[/code]. When multiplied by another [Variant] such as [Rect2] or another [Transform2D], no transformation occurs. This means that: + - The [member x] points right ([constant Vector2.RIGHT]); + - The [member y] points up ([constant Vector2.UP]). + [codeblock] + var transform = Transform2D.IDENTITY + print("| X | Y | Origin") + print("| %s | %s | %s" % [transform.x.x, transform.y.x, transform.origin.x]) + print("| %s | %s | %s" % [transform.x.y, transform.y.y, transform.origin.y]) + # Prints: + # | X | Y | Origin + # | 1 | 0 | 0 + # | 0 | 1 | 0 + [/codeblock] + This is identical to creating [constructor Transform2D] without any parameters. This constant can be used to make your code clearer, and for consistency with C#. - The [Transform2D] that will flip something along the X axis. + When any transform is multiplied by [constant FLIP_X], it negates all components of the [member x] axis (the X column). + When [constant FLIP_X] is multiplied by any basis, it negates the [member Vector2.x] component of all axes (the X row). - The [Transform2D] that will flip something along the Y axis. + When any transform is multiplied by [constant FLIP_Y], it negates all components of the [member y] axis (the Y column). + When [constant FLIP_Y] is multiplied by any basis, it negates the [member Vector2.y] component of all axes (the Y row). @@ -240,7 +285,7 @@ - Returns [code]true[/code] if the transforms are not equal. + Returns [code]true[/code] if the components of both transforms are not equal. [b]Note:[/b] Due to floating-point precision errors, consider using [method is_equal_approx] instead, which is more reliable. @@ -248,63 +293,69 @@ - Transforms (multiplies) each element of the [Vector2] array by the given [Transform2D] matrix. + Transforms (multiplies) every [Vector2] element of the given [PackedVector2Array] by this transformation matrix. + On larger arrays, this operation is much faster than transforming each [Vector2] individually. - Transforms (multiplies) the [Rect2] by the given [Transform2D] matrix. + Transforms (multiplies) the [Rect2] by this transformation matrix. - 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). + Transforms (multiplies) this transform by the [param right] transform. + This is the operation performed between parent and child [CanvasItem] nodes. + [b]Note:[/b] If you need to only modify one attribute of this transform, consider using one of the following methods, instead: + - For translation, see [method translated] or [method translated_local]. + - For rotation, see [method rotated] or [method rotated_local]. + - For scale, see [method scaled] or [method scaled_local]. - Transforms (multiplies) the [Vector2] by the given [Transform2D] matrix. + Transforms (multiplies) the [Vector2] by this transformation matrix. - This operator multiplies all components of the [Transform2D], including the [member origin] vector, which scales it uniformly. + Multiplies all components of the [Transform2D] by the given [float], including the [member origin]. This affects the transform's scale uniformly. - This operator multiplies all components of the [Transform2D], including the [member origin] vector, which scales it uniformly. + Multiplies all components of the [Transform2D] by the given [int], including the [member origin]. This affects the transform's scale uniformly. - This operator divides all components of the [Transform2D], including the [member origin] vector, which inversely scales it uniformly. + Divides all components of the [Transform2D] by the given [float], including the [member origin]. This affects the transform's scale uniformly. - This operator divides all components of the [Transform2D], including the [member origin] vector, which inversely scales it uniformly. + Divides all components of the [Transform2D] by the given [int], including the [member origin]. This affects the transform's scale uniformly. - Returns [code]true[/code] if the transforms are exactly equal. + Returns [code]true[/code] if the components of both transforms are exactly equal. [b]Note:[/b] Due to floating-point precision errors, consider using [method is_equal_approx] instead, which is more reliable. @@ -312,7 +363,7 @@ - Access transform components using their index. [code]t[0][/code] is equivalent to [code]t.x[/code], [code]t[1][/code] is equivalent to [code]t.y[/code], and [code]t[2][/code] is equivalent to [code]t.origin[/code]. + Accesses each axis (column) of this transform by their index. Index [code]0[/code] is the same as [member x], index [code]1[/code] is the same as [member y], and index [code]2[/code] is the same as [member origin].