+ The property is serialized and saved in the scene file (default for exported properties).

+ The property is shown in the [EditorInspector] (default for exported properties).

+ Returns the shortest normalized axis of this bounding box's [member size], as a [Vector3] ([constant Vector3.RIGHT], [constant Vector3.UP], or [constant Vector3.BACK]).

+ The region used to draw the [member atlas]. If either dimension of the region's size is [code]0[/code], the value from [member atlas] size will be used for that axis instead.

+ Visibility is checked only in parent nodes that inherit from [CanvasItem], [CanvasLayer], and [Window]. If the parent is of any other type (such as [Node], [AnimationPlayer], or [Node3D]), it is assumed to be visible.

+ [b]Note:[/b] This method uses the copied pixel data, e.g. from a image editing software or a web browser, not an image file copied from file explorer.

+ <member name="input/buffering/agile_event_flushing" type="bool" setter="" getter="">

+ If [code]true[/code], input events will be flushed just before every idle and physics frame.

+ If [code]false[/code], these events will be flushed only once per process frame, between iterations of the engine.

+ Enabling this setting can greatly improve input responsiveness, especially in devices that struggle to run at the project's intended frame rate.

+ </member>

+ <member name="input/buffering/use_accumulated_input" type="bool" setter="" getter="">

+ If [code]true[/code], similar input events sent by the operating system are accumulated. When input accumulation is enabled, all input events generated during a frame will be merged and emitted when the frame is done rendering. Therefore, this limits the number of input method calls per second to the rendering FPS.

+ Input accumulation can be disabled to get slightly more precise/reactive input at the cost of increased CPU usage.

+ [b]Note:[/b] Input accumulation is [i]enabled[/i] by default.

+ </member>

+ <constant name="BAKE_ERROR_LIGHTMAP_TOO_SMALL" value="10" enum="BakeError">

+ Lightmap baking failed as the lightmap is too small.

+ </constant>

+ <constant name="BAKE_ERROR_ATLAS_TOO_SMALL" value="11" enum="BakeError">

+ Lightmap baking failed as the lightmap was unable to fit into an atlas.

+ </constant>

+ Implemented only on Android.

+ <link title="2D Parallax">$DOCS_URL/tutorials/2d/2d_parallax.html</link>

+ [b]Note:[/b] The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.

+ [b]Note:[/b] The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.

+ [b]Note:[/b] The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.

+ [b]Note:[/b] The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.

+ [b]Note:[/b] The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.

+ [b]Note:[/b] The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.

+ Implement this in GDExtension to return the [RID] for the implementation's camera attributes object.

+ Implement this in GDExtension to return the [RID] of the implementation's environment object.

+ Implement this in GDExtension to return the implementation's [RenderSceneBuffers] object.

+ Implement this in GDExtension to return the implementation's [RenderSceneDataExtension] object.

+ VRAM-compressed unsigned red/green/blue channel data format with the floating-point value stored as-is. The format's precision is between 10 and 13 bits for the red/green/blue channels. Using BC6H texture compression (also known as BPTC HDR).

+ VRAM-compressed signed red/green/blue channel data format with the floating-point value stored as-is. The format's precision is between 10 and 13 bits for the red/green/blue channels. Using BC6H texture compression (also known as BPTC HDR).

+ 11-bit VRAM-compressed signed red channel data format with normalized value. Values are in the [code][-1.0, 1.0][/code] range. Using ETC2 texture compression.

+ 11-bit VRAM-compressed signed red/green channel data format with normalized value. Values are in the [code][-1.0, 1.0][/code] range. Using ETC2 texture compression.

+ If [param subresources] is [code]false[/code], a shallow copy is returned; nested resources within subresources are not duplicated and are shared with the original resource (with one exception; see below). If [param subresources] is [code]true[/code], a deep copy is returned; nested subresources will be duplicated and are not shared (with two exceptions; see below).

+ [param subresources] is usually respected, with the following exceptions:

+ - Subresource properties with the [constant PROPERTY_USAGE_ALWAYS_DUPLICATE] flag are always duplicated.

+ - Subresource properties with the [constant PROPERTY_USAGE_NEVER_DUPLICATE] flag are never duplicated.

+ - Subresources inside [Array] and [Dictionary] properties are never duplicated.

+ <method name="push_meta" keywords="push_url">

+ <member name="meta_underlined" type="bool" setter="set_meta_underline" getter="is_meta_underlined" default="true" keywords="url_underlined">

+ <member name="animate_physical_bones" type="bool" setter="set_animate_physical_bones" getter="get_animate_physical_bones" default="true" deprecated="">

+ If you follow the recommended workflow and explicitly have [PhysicalBoneSimulator3D] as a child of [Skeleton3D], you can control whether it is affected by raycasting without running [method physical_bones_start_simulation], by its [member SkeletonModifier3D.active].

+ However, for old (deprecated) configurations, [Skeleton3D] has an internal virtual [PhysicalBoneSimulator3D] for compatibility. This property controls the internal virtual [PhysicalBoneSimulator3D]'s [member SkeletonModifier3D.active].

+ </member>

+ [b]Note:[/b] Scene tiles all occupy one tile slot and instead use alternate tile ID to identify scene index. [method TileSetSource.get_tiles_count] will always return [code]1[/code]. Use [method get_scene_tiles_count] to get a number of scenes in a [TileSetScenesCollectionSource].

+ Use this code if you want to find the scene path at a given tile in [TileMapLayer]:

+ [codeblocks]

+ [gdscript]

+ var source_id = tile_map_layer.get_cell_source_id(Vector2i(x, y))

+ if source_id &gt; -1:

+ var scene_source = tile_map_layer.tile_set.get_source(source_id)

+ if scene_source is TileSetScenesCollectionSource:

+ var alt_id = tile_map_layer.get_cell_alternative_tile(Vector2i(x, y))

+ # The assigned PackedScene.

+ var scene = scene_source.get_scene_tile_scene(alt_id)

+ [/gdscript]

+ [csharp]

+ int sourceId = tileMapLayer.GetCellSourceId(new Vector2I(x, y));

+ if (sourceId &gt; -1)

+ {

+ TileSetSource source = tileMapLayer.TileSet.GetSource(sourceId);

+ if (source is TileSetScenesCollectionSource sceneSource)

+ {

+ int altId = tileMapLayer.GetCellAlternativeTile(new Vector2I(x, y));

+ // The assigned PackedScene.

+ PackedScene scene = sceneSource.GetSceneTileScene(altId);

+ }

+ }

+ [/csharp]

+ [/codeblocks]

+ 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.

+ [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].

+ Constructs a [Transform2D] identical to [constant IDENTITY].

+ Constructs a [Transform2D] from a given angle (in radians) and position.

+ Constructs a [Transform2D] from a given angle (in radians), scale, skew (in radians), and position.

+ Constructs a [Transform2D] from 3 [Vector2] values representing [member x], [member y], and the [member origin] (the three matrix columns).

+ 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 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 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 [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 this transform's translation. Equivalent to [member origin].

+ Returns this transform's rotation (in radians). This is equivalent to [member x]'s angle (see [method Vector2.angle]).

+ 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 this transform's skew (in radians).

+ 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 [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 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.

+ Returns a copy of the transform rotated such that the rotated X-axis points towards the [param target] position, in global space.

+ 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.

+ 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 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 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]. 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#.

+ 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).

+ 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).

+ Returns [code]true[/code] if the components of both transforms are not equal.

+ 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 this transformation matrix.

+ 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 this transformation matrix.

+ Multiplies all components of the [Transform2D] by the given [float], including the [member origin]. This affects the transform's scale uniformly.

+ Multiplies all components of the [Transform2D] by the given [int], including the [member origin]. This affects the transform's scale uniformly.

+ Divides all components of the [Transform2D] by the given [float], including the [member origin]. This affects the transform's scale 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 components of both transforms are exactly equal.

+ 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].

+ [param frequency] is the frequency of the pulse, set to [code]0.0[/code] to have the system use a default frequency.

+ [param amplitude] is the amplitude of the pulse between [code]0.0[/code] and [code]1.0[/code].

+ [param duration_sec] is the duration of the pulse in seconds.

+ [param delay_sec] is a delay in seconds before the pulse is given.

+ [param frequency] is the frequency of the pulse, set to [code]0.0[/code] to have the system use a default frequency.

+ [param amplitude] is the amplitude of the pulse between [code]0.0[/code] and [code]1.0[/code].

+ [param duration_sec] is the duration of the pulse in seconds.

+ [param delay_sec] is a delay in seconds before the pulse is given.