<method name="area_set_area_monitor_callback">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="callback" type="Callable" />
			<description>
				Sets the area's area monitor callback. This callback will be called when any other (shape of an) area enters or exits (a shape of) the given area, and must take the following five parameters:
				1. an integer [code]status[/code]: either [constant AREA_BODY_ADDED] or [constant AREA_BODY_REMOVED] depending on whether the other area's shape entered or exited the area,
				2. an [RID] [code]area_rid[/code]: the [RID] of the other area that entered or exited the area,
				3. an integer [code]instance_id[/code]: the [code]ObjectID[/code] attached to the other area,
				4. an integer [code]area_shape_idx[/code]: the index of the shape of the other area that entered or exited the area,
				5. an integer [code]self_shape_idx[/code]: the index of the shape of the area where the other area entered or exited.
				By counting (or keeping track of) the shapes that enter and exit, it can be determined if an area (with all its shapes) is entering for the first time or exiting for the last time.
			</description>
		</method>
		<method name="area_set_collision_layer">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="layer" type="int" />
			<description>
				Assigns the area to one or many physics layers, via a bitmask.
			</description>
		</method>
		<method name="area_set_collision_mask">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="mask" type="int" />
			<description>
				Sets which physics layers the area will monitor, via a bitmask.
			</description>
		</method>
		<method name="area_set_monitor_callback">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="callback" type="Callable" />
			<description>
				Sets the area's body monitor callback. This callback will be called when any other (shape of a) body enters or exits (a shape of) the given area, and must take the following five parameters:
				1. an integer [code]status[/code]: either [constant AREA_BODY_ADDED] or [constant AREA_BODY_REMOVED] depending on whether the other body shape entered or exited the area,
				2. an [RID] [code]body_rid[/code]: the [RID] of the body that entered or exited the area,
				3. an integer [code]instance_id[/code]: the [code]ObjectID[/code] attached to the body,
				4. an integer [code]body_shape_idx[/code]: the index of the shape of the body that entered or exited the area,
				5. an integer [code]self_shape_idx[/code]: the index of the shape of the area where the body entered or exited.
				By counting (or keeping track of) the shapes that enter and exit, it can be determined if a body (with all its shapes) is entering for the first time or exiting for the last time.
			</description>
		</method>
		<method name="area_set_monitorable">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="monitorable" type="bool" />
			<description>
				Sets whether the area is monitorable or not. If [param monitorable] is [code]true[/code], the area monitoring callback of other areas will be called when this area enters or exits them.
			</description>
		</method>
		<method name="area_set_param">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="param" type="int" enum="PhysicsServer2D.AreaParameter" />
			<param index="2" name="value" type="Variant" />
			<description>
				Sets the value of the given area parameter. See [enum AreaParameter] for the list of available parameters.
			</description>
		</method>
		<method name="area_set_shape">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="shape_idx" type="int" />
			<param index="2" name="shape" type="RID" />
			<description>
				Replaces the area's shape at the given index by another shape, while not affecting the [code]transform[/code] and [code]disabled[/code] properties at the same index.
			</description>
		</method>
		<method name="area_set_shape_disabled">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="shape_idx" type="int" />
			<param index="2" name="disabled" type="bool" />
			<description>
				Sets the disabled property of the area's shape with the given index. If [param disabled] is [code]true[/code], then the shape will not detect any other shapes entering or exiting it.
			</description>
		</method>
		<method name="area_set_shape_transform">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="shape_idx" type="int" />
			<param index="2" name="transform" type="Transform2D" />
			<description>
				Sets the local transform matrix of the area's shape with the given index.
			</description>
		</method>
		<method name="area_set_space">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="space" type="RID" />
			<description>
				Adds the area to the given space, after removing the area from the previously assigned space (if any).
				[b]Note:[/b] To remove an area from a space without immediately adding it back elsewhere, use [code]PhysicsServer2D.area_set_space(area, RID())[/code].
			</description>
		</method>
		<method name="area_set_transform">
			<return type="void" />
			<param index="0" name="area" type="RID" />
			<param index="1" name="transform" type="Transform2D" />
			<description>
				Sets the transform matrix of the area.
			</description>
		</method>
		<method name="body_add_collision_exception">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="excepted_body" type="RID" />
			<description>
				Adds [param excepted_body] to the body's list of collision exceptions, so that collisions with it are ignored.
			</description>
		</method>
		<method name="body_add_constant_central_force">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="force" type="Vector2" />
			<description>
				Adds a constant directional force to the body. The force does not affect rotation. The force remains applied over time until cleared with [code]PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0))[/code].
				This is equivalent to using [method body_add_constant_force] at the body's center of mass.
			</description>
		</method>


<method name="body_set_collision_layer">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="layer" type="int" />
			<description>
				Sets the physics layer or layers the body belongs to, via a bitmask.
			</description>
		</method>
		<method name="body_set_collision_mask">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="mask" type="int" />
			<description>
				Sets the physics layer or layers the body can collide with, via a bitmask.
			</description>
		</method>
		<method name="body_set_collision_priority">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="priority" type="float" />
			<description>
				Sets the body's collision priority. This is used in the depenetration phase of [method body_test_motion]. The higher the priority is, the lower the penetration into the body will be.
			</description>
		</method>
		<method name="body_set_constant_force">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="force" type="Vector2" />
			<description>
				Sets the body's total constant positional force applied during each physics update.
				See [method body_add_constant_force] and [method body_add_constant_central_force].
			</description>
		</method>
		<method name="body_set_constant_torque">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="torque" type="float" />
			<description>
				Sets the body's total constant rotational force applied during each physics update.
				See [method body_add_constant_torque].
			</description>
		</method>
		<method name="body_set_continuous_collision_detection_mode">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="mode" type="int" enum="PhysicsServer2D.CCDMode" />
			<description>
				Sets the continuous collision detection mode using one of the [enum CCDMode] constants.
				Continuous collision detection tries to predict where a moving body would collide in between physics updates, instead of moving it and correcting its movement if it collided.
			</description>
		</method>
		<method name="body_set_force_integration_callback">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="callable" type="Callable" />
			<param index="2" name="userdata" type="Variant" default="null" />
			<description>
				Sets the body's custom force integration callback function to [param callable]. Use an empty [Callable] ([code skip-lint]Callable()[/code]) to clear the custom callback.
				The function [param callable] will be called every physics tick, before the standard force integration (see [method body_set_omit_force_integration]). It can be used for example to update the body's linear and angular velocity based on contact with other bodies.
				If [param userdata] is not [code]null[/code], the function [param callable] must take the following two parameters:
				1. [code]state[/code]: a [PhysicsDirectBodyState2D] used to retrieve and modify the body's state,
				2. [code skip-lint]userdata[/code]: a [Variant]; its value will be the [param userdata] passed into this method.
				If [param userdata] is [code]null[/code], then [param callable] must take only the [code]state[/code] parameter.
			</description>
		</method>
		<method name="body_set_max_contacts_reported">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="amount" type="int" />
			<description>
				Sets the maximum number of contacts that the body can report. If [param amount] is greater than zero, then the body will keep track of at most this many contacts with other bodies.
			</description>
		</method>
		<method name="body_set_mode">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="mode" type="int" enum="PhysicsServer2D.BodyMode" />
			<description>
				Sets the body's mode. See [enum BodyMode] for the list of available modes.
			</description>
		</method>
		<method name="body_set_omit_force_integration">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="enable" type="bool" />
			<description>
				Sets whether the body omits the standard force integration. If [param enable] is [code]true[/code], the body will not automatically use applied forces, torques, and damping to update the body's linear and angular velocity. In this case, [method body_set_force_integration_callback] can be used to manually update the linear and angular velocity instead.
				This method is called when the property [member RigidBody2D.custom_integrator] is set.
			</description>
		</method>
		<method name="body_set_param">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="param" type="int" enum="PhysicsServer2D.BodyParameter" />
			<param index="2" name="value" type="Variant" />
			<description>
				Sets the value of the given body parameter. See [enum BodyParameter] for the list of available parameters.
			</description>
		</method>
		<method name="body_set_shape">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="shape_idx" type="int" />
			<param index="2" name="shape" type="RID" />
			<description>
				Replaces the body's shape at the given index by another shape, while not affecting the [code]transform[/code], [code]disabled[/code], and one-way collision properties at the same index.
			</description>
		</method>
		<method name="body_set_shape_as_one_way_collision">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="shape_idx" type="int" />
			<param index="2" name="enable" type="bool" />
			<param index="3" name="margin" type="float" />
			<description>
				Sets the one-way collision properties of the body's shape with the given index. If [param enable] is [code]true[/code], the one-way collision direction given by the shape's local upward axis [code]body_get_shape_transform(body, shape_idx).y[/code] will be used to ignore collisions with the shape in the opposite direction, and to ensure depenetration of kinematic bodies happens in this direction.
			</description>
		</method>
		<method name="body_set_shape_disabled">
			<return type="void" />
			<param index="0" name="body" type="RID" />
			<param index="1" name="shape_idx" type="int" />
			<param index="2" name="disabled" type="bool" />
			<description>
				Sets the disabled property of the body's shape with the given index. If [param disabled] is [code]true[/code], then the shape will be ignored in all collision detection.
			</description>
		</method>


<members>
		<member name="collide_with_areas" type="bool" setter="set_collide_with_areas" getter="is_collide_with_areas_enabled" default="false">
			If [code]true[/code], collisions with [Area2D]s will be reported.
		</member>
		<member name="collide_with_bodies" type="bool" setter="set_collide_with_bodies" getter="is_collide_with_bodies_enabled" default="true">
			If [code]true[/code], collisions with [PhysicsBody2D]s will be reported.
		</member>
		<member name="collision_mask" type="int" setter="set_collision_mask" getter="get_collision_mask" default="1">
			The shape's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See [url=$DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks]Collision layers and masks[/url] in the documentation for more information.
		</member>
		<member name="collision_result" type="Array" setter="" getter="get_collision_result" default="[]">
			Returns the complete collision information from the collision sweep. The data returned is the same as in the [method PhysicsDirectSpaceState2D.get_rest_info] method.
		</member>
		<member name="enabled" type="bool" setter="set_enabled" getter="is_enabled" default="true">
			If [code]true[/code], collisions will be reported.
		</member>
		<member name="exclude_parent" type="bool" setter="set_exclude_parent_body" getter="get_exclude_parent_body" default="true">
			If [code]true[/code], the parent node will be excluded from collision detection.
		</member>
		<member name="margin" type="float" setter="set_margin" getter="get_margin" default="0.0">
			The collision margin for the shape. A larger margin helps detecting collisions more consistently, at the cost of precision.
		</member>
		<member name="max_results" type="int" setter="set_max_results" getter="get_max_results" default="32">
			The number of intersections can be limited with this parameter, to reduce the processing time.
		</member>
		<member name="shape" type="Shape2D" setter="set_shape" getter="get_shape">
			The shape to be used for collision queries.
		</member>
		<member name="target_position" type="Vector2" setter="set_target_position" getter="get_target_position" default="Vector2(0, 50)">
			The shape's destination point, relative to this node's [member Node2D.position].
		</member>
	</members>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="HBoxContainer" inherits="BoxContainer" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A container that arranges its child controls horizontally.
	</brief_description>
	<description>
		A variant of [BoxContainer] that can only arrange its child controls horizontally. Child controls are rearranged automatically when their minimum size changes.
	</description>
	<tutorials>
		<link title="Using Containers">$DOCS_URL/tutorials/ui/gui_containers.html</link>
	</tutorials>
</class>


<method name="get_video_adapter_driver_info" qualifiers="const">
			<return type="PackedStringArray" />
			<description>
				Returns the video adapter driver name and version for the user's currently active graphics card, as a [PackedStringArray]. See also [method RenderingServer.get_video_adapter_api_version].
				The first element holds the driver name, such as [code]nvidia[/code], [code]amdgpu[/code], etc.
				The second element holds the driver version. For example, on the [code]nvidia[/code] driver on a Linux/BSD platform, the version is in the format [code]510.85.02[/code]. For Windows, the driver's format is [code]31.0.15.1659[/code].
				[b]Note:[/b] This method is only supported on Linux/BSD and Windows when not running in headless mode. On other platforms, it returns an empty array.
			</description>
		</method>
		<method name="has_environment" qualifiers="const">
			<return type="bool" />
			<param index="0" name="variable" type="String" />
			<description>
				Returns [code]true[/code] if the environment variable with the name [param variable] exists.
				[b]Note:[/b] Double-check the casing of [param variable]. Environment variable names are case-sensitive on all platforms except Windows.
			</description>
		</method>
		<method name="has_feature" qualifiers="const">
			<return type="bool" />
			<param index="0" name="tag_name" type="String" />
			<description>
				Returns [code]true[/code] if the feature for the given feature tag is supported in the currently running instance, depending on the platform, build, etc. Can be used to check whether you're currently running a debug build, on a certain platform or arch, etc. Refer to the [url=$DOCS_URL/tutorials/export/feature_tags.html]Feature Tags[/url] documentation for more details.
				[b]Note:[/b] Tag names are case-sensitive.
				[b]Note:[/b] On the Web platform, one of the following additional tags is defined to indicate the host platform: [code]web_android[/code], [code]web_ios[/code], [code]web_linuxbsd[/code], [code]web_macos[/code], or [code]web_windows[/code].
			</description>
		</method>
		<method name="is_debug_build" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the Godot binary used to run the project is a [i]debug[/i] export template, or when running in the editor.
				Returns [code]false[/code] if the Godot binary used to run the project is a [i]release[/i] export template.
				[b]Note:[/b] To check whether the Godot binary used to run the project is an export template (debug or release), use [code]OS.has_feature("template")[/code] instead.
			</description>
		</method>
		<method name="is_keycode_unicode" qualifiers="const">
			<return type="bool" />
			<param index="0" name="code" type="int" />
			<description>
				Returns [code]true[/code] if the input keycode corresponds to a Unicode character. For a list of codes, see the [enum Key] constants.
				[codeblocks]
				[gdscript]
				print(OS.is_keycode_unicode(KEY_G))      # Prints true
				print(OS.is_keycode_unicode(KEY_KP_4))   # Prints true
				print(OS.is_keycode_unicode(KEY_TAB))    # Prints false
				print(OS.is_keycode_unicode(KEY_ESCAPE)) # Prints false
				[/gdscript]
				[csharp]
				GD.Print(OS.IsKeycodeUnicode((long)Key.G));      // Prints true
				GD.Print(OS.IsKeycodeUnicode((long)Key.Kp4));    // Prints true
				GD.Print(OS.IsKeycodeUnicode((long)Key.Tab));    // Prints false
				GD.Print(OS.IsKeycodeUnicode((long)Key.Escape)); // Prints false
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="is_process_running" qualifiers="const">
			<return type="bool" />
			<param index="0" name="pid" type="int" />
			<description>
				Returns [code]true[/code] if the child process ID ([param pid]) is still running or [code]false[/code] if it has terminated. [param pid] must be a valid ID generated from [method create_process].
				[b]Note:[/b] This method is implemented on Android, iOS, Linux, macOS, and Windows.
			</description>
		</method>
		<method name="is_restart_on_exit_set" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the project will automatically restart when it exits for any reason, [code]false[/code] otherwise. See also [method set_restart_on_exit] and [method get_restart_on_exit_arguments].
			</description>
		</method>
		<method name="is_sandboxed" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the application is running in the sandbox.
				[b]Note:[/b] This method is only implemented on macOS and Linux.
			</description>
		</method>
		<method name="is_stdout_verbose" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the engine was executed with the [code]--verbose[/code] or [code]-v[/code] command line argument, or if [member ProjectSettings.debug/settings/stdout/verbose_stdout] is [code]true[/code]. See also [method @GlobalScope.print_verbose].
			</description>
		</method>
		<method name="is_userfs_persistent" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the [code]user://[/code] file system is persistent, that is, its state is the same after a player quits and starts the game again. Relevant to the Web platform, where this persistence may be unavailable.
			</description>
		</method>
		<method name="kill">
			<return type="int" enum="Error" />
			<param index="0" name="pid" type="int" />
			<description>
				Kill (terminate) the process identified by the given process ID ([param pid]), such as the ID returned by [method execute] in non-blocking mode. See also [method crash].
				[b]Note:[/b] This method can also be used to kill processes that were not spawned by the engine.
				[b]Note:[/b] This method is implemented on Android, iOS, Linux, macOS and Windows.
			</description>
		</method>
		<method name="move_to_trash" qualifiers="const">
			<return type="int" enum="Error" />
			<param index="0" name="path" type="String" />
			<description>
				Moves the file or directory at the given [param path] to the system's recycle bin. See also [method DirAccess.remove].
				The method takes only global paths, so you may need to use [method ProjectSettings.globalize_path]. Do not use it for files in [code]res://[/code] as it will not work in exported projects.
				Returns [constant FAILED] if the file or directory cannot be found, or the system does not support this method.
				[codeblocks]
				[gdscript]
				var file_to_remove = "user://slot1.save"
				OS.move_to_trash(ProjectSettings.globalize_path(file_to_remove))
				[/gdscript]
				[csharp]
				var fileToRemove = "user://slot1.save";
				OS.MoveToTrash(ProjectSettings.GlobalizePath(fileToRemove));
				[/csharp]
				[/codeblocks]
				[b]Note:[/b] This method is implemented on Android, Linux, macOS and Windows.
				[b]Note:[/b] If the user has disabled the recycle bin on their system, the file will be permanently deleted instead.
			</description>
		</method>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="Basis" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A 3×3 matrix for representing 3D rotation and scale.
	</brief_description>
	<description>
		The [Basis] built-in [Variant] type is a 3×3 [url=https://en.wikipedia.org/wiki/Matrix_(mathematics)]matrix[/url] used to represent 3D rotation, scale, and shear. It is frequently used within a [Transform3D].
		A [Basis] is composed by 3 axis vectors, each representing a column of the matrix: [member x], [member y], and [member z]. The length of each axis ([method Vector3.length]) influences the basis's scale, while the direction of all axes influence the rotation. Usually, these axes are perpendicular to one another. However, when you rotate any axis individually, the basis becomes sheared. Applying a sheared basis to a 3D model will make the model appear distorted.
		A [Basis] is [b]orthogonal[/b] if its axes are perpendicular to each other. A basis is [b]normalized[/b] if the length of every axis is [code]1[/code]. A basis is [b]uniform[/b] if all axes share the same length (see [method get_scale]). A basis is [b]orthonormal[/b] if it is both orthogonal and normalized, which allows it to only represent rotations. A basis is [b]conformal[/b] if it is both orthogonal and uniform, which ensures it is not distorted.
		For a general introduction, see the [url=$DOCS_URL/tutorials/math/matrices_and_transforms.html]Matrices and transforms[/url] tutorial.
		[b]Note:[/b] Godot uses a [url=https://en.wikipedia.org/wiki/Right-hand_rule]right-handed coordinate system[/url], which is a common standard. For directions, the convention for built-in types like [Camera3D] is for -Z to point forward (+X is right, +Y is up, and +Z is back). Other objects may use different direction conventions. For more information, see the [url=$DOCS_URL/tutorials/assets_pipeline/importing_3d_scenes/model_export_considerations.html#d-asset-direction-conventions]3D asset direction conventions[/url] tutorial.
		[b]Note:[/b] The basis matrices are exposed as [url=https://www.mindcontrol.org/~hplus/graphics/matrix-layout.html]column-major[/url] order, which is the same as OpenGL. However, they are stored internally in row-major order, which is the same as DirectX.
	</description>
	<tutorials>
		<link title="Math documentation index">$DOCS_URL/tutorials/math/index.html</link>
		<link title="Matrices and transforms">$DOCS_URL/tutorials/math/matrices_and_transforms.html</link>
		<link title="Using 3D transforms">$DOCS_URL/tutorials/3d/using_transforms.html</link>
		<link title="Matrix Transform Demo">https://godotengine.org/asset-library/asset/2787</link>
		<link title="3D Platformer Demo">https://godotengine.org/asset-library/asset/2748</link>
		<link title="3D Voxel Demo">https://godotengine.org/asset-library/asset/2755</link>
		<link title="2.5D Game Demo">https://godotengine.org/asset-library/asset/2783</link>
	</tutorials>
	<constructors>
		<constructor name="Basis">
			<return type="Basis" />
			<description>
				Constructs a [Basis] identical to the [constant IDENTITY].
			</description>
		</constructor>
		<constructor name="Basis">
			<return type="Basis" />
			<param index="0" name="from" type="Basis" />
			<description>
				Constructs a [Basis] as a copy of the given [Basis].
			</description>
		</constructor>
		<constructor name="Basis">
			<return type="Basis" />
			<param index="0" name="axis" type="Vector3" />
			<param index="1" name="angle" type="float" />
			<description>
				Constructs a [Basis] that only represents rotation, rotated around the [param axis] by the given [param angle], in radians. The axis must be a normalized vector.
				[b]Note:[/b] This is the same as using [method rotated] on the [constant IDENTITY] basis. With more than one angle consider using [method from_euler], instead.
			</description>
		</constructor>
		<constructor name="Basis">
			<return type="Basis" />
			<param index="0" name="from" type="Quaternion" />
			<description>
				Constructs a [Basis] that only represents rotation from the given [Quaternion].
				[b]Note:[/b] Quaternions [i]only[/i] store rotation, not scale. Because of this, conversions from [Basis] to [Quaternion] cannot always be reversed.
			</description>
		</constructor>
		<constructor name="Basis">
			<return type="Basis" />
			<param index="0" name="x_axis" type="Vector3" />
			<param index="1" name="y_axis" type="Vector3" />
			<param index="2" name="z_axis" type="Vector3" />
			<description>
				Constructs a [Basis] from 3 axis vectors. These are the columns of the basis matrix.
			</description>
		</constructor>
	</constructors>
	<m


ethods>
		<method name="determinant" qualifiers="const">
			<return type="float" />
			<description>
				Returns the [url=https://en.wikipedia.org/wiki/Determinant]determinant[/url] of this 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.
			</description>
		</method>
		<method name="from_euler" qualifiers="static">
			<return type="Basis" />
			<param index="0" name="euler" type="Vector3" />
			<param index="1" name="order" type="int" default="2" />
			<description>
				Constructs a new [Basis] that only represents rotation from the given [Vector3] of [url=https://en.wikipedia.org/wiki/Euler_angles]Euler angles[/url], in radians.
				- The [member Vector3.x] should contain the angle around the [member x] axis (pitch).
				- The [member Vector3.y] should contain the angle around the [member y] axis (yaw).
				- The [member Vector3.z] should contain the angle around the [member z] axis (roll).
				[codeblocks]
				[gdscript]
				# Creates a Basis whose z axis points down.
				var my_basis = Basis.from_euler(Vector3(TAU / 4, 0, 0))

				print(my_basis.z) # Prints (0, -1, 0).
				[/gdscript]
				[csharp]
				// Creates a Basis whose z axis points down.
				var myBasis = Basis.FromEuler(new Vector3(Mathf.Tau / 4.0f, 0.0f, 0.0f));

				GD.Print(myBasis.Z); // Prints (0, -1, 0).
				[/csharp]
				[/codeblocks]
				The order of each consecutive rotation can be changed with [param order] (see [enum EulerOrder] constants). By default, the YXZ convention is used ([constant EULER_ORDER_YXZ]): the basis rotates first around the Y axis (yaw), then X (pitch), and lastly Z (roll). When using the opposite method [method get_euler], this order is reversed.
			</description>
		</method>
		<method name="from_scale" qualifiers="static">
			<return type="Basis" />
			<param index="0" name="scale" type="Vector3" />
			<description>
				Constructs a new [Basis] that only represents scale, with no rotation or shear, from the given [param scale] vector.
				[codeblocks]
				[gdscript]
				var my_basis = Basis.from_scale(Vector3(2, 4, 8))

				print(my_basis.x) # Prints (2, 0, 0).
				print(my_basis.y) # Prints (0, 4, 0).
				print(my_basis.z) # Prints (0, 0, 8).
				[/gdscript]
				[csharp]
				var myBasis = Basis.FromScale(new Vector3(2.0f, 4.0f, 8.0f));

				GD.Print(myBasis.X); // Prints (2, 0, 0).
				GD.Print(myBasis.Y); // Prints (0, 4, 0).
				GD.Print(myBasis.Z); // Prints (0, 0, 8).
				[/csharp]
				[/codeblocks]
				[b]Note:[/b] In linear algebra, the matrix of this basis is also known as a [url=https://en.wikipedia.org/wiki/Diagonal_matrix]diagonal matrix[/url].
			</description>
		</method>
		<method name="get_euler" qualifiers="const">
			<return type="Vector3" />
			<param index="0" name="order" type="int" default="2" />
			<description>
				Returns this basis's rotation as a [Vector3] of [url=https://en.wikipedia.org/wiki/Euler_angles]Euler angles[/url], in radians.
				- The [member Vector3.x] contains the angle around the [member x] axis (pitch);
				- The [member Vector3.y] contains the angle around the [member y] axis (yaw);
				- The [member Vector3.z] contains the angle around the [member z] axis (roll).
				The order of each consecutive rotation can be changed with [param order] (see [enum EulerOrder] constants). By default, the YXZ convention is used ([constant EULER_ORDER_YXZ]): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method [method from_euler], this order is reversed.
				[b]Note:[/b] Euler angles are much more intuitive but are not suitable for 3D math. Because of this, consider using the [method get_rotation_quaternion] method instead, which returns a [Quaternion].
				[b]Note:[/b] In the Inspector dock, a basis's rotation is often displayed in Euler angles (in degrees), as is the case with the [member Node3D.rotation] property.
			</description>
		</method>
		<method name="get_rotation_quaternion" qualifiers="const">
			<return type="Quaternion" />
			<description>
				Returns this basis's rotation as a [Quaternion].
				[b]Note:[/b] Quatenions are much more suitable for 3D math but are less intuitive. For user interfaces, consider using the [method get_euler] method, which returns Euler angles.
			</description>
		</method>
		<method name="get_scale" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the length of each axis of this basis, as a [Vector3]. If the basis is not sheared, this is the scaling factor. It is not affected by rotation.
				[codeblocks]
				[gdscript]
				var my_basis = Basis(
				    Vector3(2, 0, 0),
				    Vector3(0, 4, 0),
				    Vector3(0, 0, 8)
				)
				# Rotating the Basis in any way preserves its scale.
				my_basis = my_basis.rotated(Vector3.UP, TAU / 2)
				my_basis = my_basis.rotated(Vector3.RIGHT, TAU / 4)

				print(my_basis.get_scale()) # Prints (2, 4, 8).
				[/gdscript]
				[csharp]
				var myBasis = new Basis(
				    Vector3(2.0f, 0.0f, 0.0f),
				    Vector3(0.0f, 4.0f, 0.0f),
				    Vector3(0.0f, 0.0f, 8.0f)
				);
				// Rotating the Basis in any way preserves its scale.
				myBasis = myBasis.Rotated(Vector3.Up, Mathf.Tau / 2.0f);
				myBasis = myBasis.Rotated(Vector3.Right, Mathf.Tau / 4.0f);

				GD.Print(myBasis.Scale); // Prints (2, 4, 8).
				[/csharp]
				[/codeblocks]
				[b]Note:[/b] If the value returned by [method determinant] is negative, the scale is also negative.
			</description>
		</method>
		<method name="inverse" qualifiers="const">
			<return type="Basis" />
			<description>
				Returns the [url=https://en.wikipedia.org/wiki/Invertible_matrix]inverse of this basis's matrix[/url].
			</description>
		</method>
		<method name="is_conformal" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if this 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.
			</description>
		</method>
		<m


ethod name="is_equal_approx" qualifiers="const">
			<return type="bool" />
			<param index="0" name="b" type="Basis" />
			<description>
				Returns [code]true[/code] if this basis and [param b] are approximately equal, by calling [method @GlobalScope.is_equal_approx] on all vector components.
			</description>
		</method>
		<method name="is_finite" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if this basis is finite, by calling [method @GlobalScope.is_finite] on all vector components.
			</description>
		</method>
		<method name="looking_at" qualifiers="static">
			<return type="Basis" />
			<param index="0" name="target" type="Vector3" />
			<param index="1" name="up" type="Vector3" default="Vector3(0, 1, 0)" />
			<param index="2" name="use_model_front" type="bool" default="false" />
			<description>
				Creates a new [Basis] with a rotation such that the forward axis (-Z) points towards the [param target] position.
				By default, the -Z axis (camera forward) is treated as forward (implies +X is right). If [param use_model_front] is [code]true[/code], the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the [param target] position.
				The up axis (+Y) points as close to the [param up] vector as possible while staying perpendicular to the forward axis. The returned basis is orthonormalized (see [method orthonormalized]). The [param target] and [param up] vectors cannot be [constant Vector3.ZERO], and cannot be parallel to each other.
			</description>
		</method>
		<method name="orthonormalized" qualifiers="const">
			<return type="Basis" />
			<description>
				Returns the orthonormalized version of this basis. 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.
				It is often useful to call this method to avoid rounding errors on a rotating basis:
				[codeblocks]
				[gdscript]
				# Rotate this Node3D every frame.
				func _process(delta):
				    basis = basis.rotated(Vector3.UP, TAU * delta)
				    basis = basis.rotated(Vector3.RIGHT, TAU * delta)

				    basis = basis.orthonormalized()
				[/gdscript]
				[csharp]
				// Rotate this Node3D every frame.
				public override void _Process(double delta)
				{
				    Basis = Basis.Rotated(Vector3.Up, Mathf.Tau * (float)delta)
				                 .Rotated(Vector3.Right, Mathf.Tau * (float)delta)
				                 .Orthonormalized();
				}
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="rotated" qualifiers="const">
			<return type="Basis" />
			<param index="0" name="axis" type="Vector3" />
			<param index="1" name="angle" type="float" />
			<description>
				Returns this basis rotated around the given [param axis] by [param angle] (in radians). The [param axis] must be a normalized vector (see [method Vector3.normalized]).
				Positive values rotate this basis clockwise around the axis, while negative values rotate it counterclockwise.
				[codeblocks]
				[gdscript]
				var my_basis = Basis.IDENTITY
				var angle = TAU / 2

				my_basis = my_basis.rotated(Vector3.UP, angle)    # Rotate around the up axis (yaw).
				my_basis = my_basis.rotated(Vector3.RIGHT, angle) # Rotate around the right axis (pitch).
				my_basis = my_basis.rotated(Vector3.BACK, angle)  # Rotate around the back axis (roll).
				[/gdscript]
				[csharp]
				var myBasis = Basis.Identity;
				var angle = Mathf.Tau / 2.0f;

				myBasis = myBasis.Rotated(Vector3.Up, angle);    // Rotate around the up axis (yaw).
				myBasis = myBasis.Rotated(Vector3.Right, angle); // Rotate around the right axis (pitch).
				myBasis = myBasis.Rotated(Vector3.Back, angle);  // Rotate around the back axis (roll).
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="scaled" qualifiers="const">
			<return type="Basis" />
			<param index="0" name="scale" type="Vector3" />
			<description>
				Returns this basis with each axis's components scaled by the given [param scale]'s components.
				The basis matrix's rows are multiplied by [param scale]'s components. This operation is a global scale (relative to the parent).
				[codeblocks]
				[gdscript]
				var my_basis = Basis(
				    Vector3(1, 1, 1),
				    Vector3(2, 2, 2),
				    Vector3(3, 3, 3)
				)
				my_basis = my_basis.scaled(Vector3(0, 2, -2))

				print(my_basis.x) # Prints (0, 2, -2).
				print(my_basis.y) # Prints (0, 4, -4).
				print(my_basis.z) # Prints (0, 6, -6).
				[/gdscript]
				[csharp]
				var myBasis = new Basis(
				    new Vector3(1.0f, 1.0f, 1.0f),
				    new Vector3(2.0f, 2.0f, 2.0f),
				    new Vector3(3.0f, 3.0f, 3.0f)
				);
				myBasis = myBasis.Scaled(new Vector3(0.0f, 2.0f, -2.0f));

				GD.Print(myBasis.X); // Prints (0, 2, -2).
				GD.Print(myBasis.Y); // Prints (0, 4, -4).
				GD.Print(myBasis.Z); // Prints (0, 6, -6).
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="slerp" qualifiers="const" keywords="interpolate">
			<return type="Basis" />
			<param index="0" name="to" type="Basis" />
			<param index="1" name="weight" type="float" />
			<description>
				Performs a spherical-linear interpolation with the [param to] basis, given a [param weight]. Both this basis and [param to] should represent a rotation.
				[b]Example:[/b] Smoothly rotate a [Node3D] to the target basis over time, with a [Tween].
				[codeblock]
				var start_basis = Basis.IDENTITY
				var target_basis = Basis.IDENTITY.rotated(Vector3.UP, TAU / 2)

				func _ready():
				    create_tween().tween_method(interpolate, 0.0, 1.0, 5.0).set_trans(Tween.TRANS_EXPO)

				func interpolate(weight):
				    basis = start_basis.slerp(target_basis, weight)
				[/codeblock]
			</description>
		</method>
		<method name="tdotx" qualifiers="const">
			<return type="float" />
			<param index="0" name="with" type="Vector3" />
			<description>
				Returns the transposed dot product between [param with] and the [member x] axis (see [method transposed]).
				This is equivalent to [code]basis.x.dot(vector)[/code].
			</description>
		</method>
		<method name="tdoty" qualifiers="const">
			<return type="float" />
			<param index="0" name="with" type="Vector3" />
			<description>
				Returns the transposed dot product between [param with] and the [member y] axis (see [method transposed]).
				This is equivalent to [code]basis.y.dot(vector)[/code].
			</description>
		</method>
		<m


<method name="set_loops">
			<return type="Tween" />
			<param index="0" name="loops" type="int" default="0" />
			<description>
				Sets the number of times the tweening sequence will be repeated, i.e. [code]set_loops(2)[/code] will run the animation twice.
				Calling this method without arguments will make the [Tween] run infinitely, until either it is killed with [method kill], the [Tween]'s bound node is freed, or all the animated objects have been freed (which makes further animation impossible).
				[b]Warning:[/b] Make sure to always add some duration/delay when using infinite loops. To prevent the game freezing, 0-duration looped animations (e.g. a single [CallbackTweener] with no delay) are stopped after a small number of loops, which may produce unexpected results. If a [Tween]'s lifetime depends on some node, always use [method bind_node].
			</description>
		</method>
		<method name="set_parallel">
			<return type="Tween" />
			<param index="0" name="parallel" type="bool" default="true" />
			<description>
				If [param parallel] is [code]true[/code], the [Tweener]s appended after this method will by default run simultaneously, as opposed to sequentially.
				[b]Note:[/b] Just like with [method parallel], the tweener added right before this method will also be part of the parallel step.
				[codeblock]
				tween.tween_property(self, "position", Vector2(300, 0), 0.5)
				tween.set_parallel()
				tween.tween_property(self, "modulate", Color.GREEN, 0.5) # Runs together with the position tweener.
				[/codeblock]
			</description>
		</method>
		<method name="set_pause_mode">
			<return type="Tween" />
			<param index="0" name="mode" type="int" enum="Tween.TweenPauseMode" />
			<description>
				Determines the behavior of the [Tween] when the [SceneTree] is paused. Check [enum TweenPauseMode] for options.
				Default value is [constant TWEEN_PAUSE_BOUND].
			</description>
		</method>
		<method name="set_process_mode">
			<return type="Tween" />
			<param index="0" name="mode" type="int" enum="Tween.TweenProcessMode" />
			<description>
				Determines whether the [Tween] should run after process frames (see [method Node._process]) or physics frames (see [method Node._physics_process]).
				Default value is [constant TWEEN_PROCESS_IDLE].
			</description>
		</method>
		<method name="set_speed_scale">
			<return type="Tween" />
			<param index="0" name="speed" type="float" />
			<description>
				Scales the speed of tweening. This affects all [Tweener]s and their delays.
			</description>
		</method>
		<method name="set_trans">
			<return type="Tween" />
			<param index="0" name="trans" type="int" enum="Tween.TransitionType" />
			<description>
				Sets the default transition type for [PropertyTweener]s and [MethodTweener]s animated by this [Tween].
				If not specified, the default value is [constant TRANS_LINEAR].
			</description>
		</method>
		<method name="stop">
			<return type="void" />
			<description>
				Stops the tweening and resets the [Tween] to its initial state. This will not remove any appended [Tweener]s.
				[b]Note:[/b] If a Tween is stopped and not bound to any node, it will exist indefinitely until manually started or invalidated. If you lose a reference to such Tween, you can retrieve it using [method SceneTree.get_processed_tweens].
			</description>
		</method>
		<method name="tween_callback">
			<return type="CallbackTweener" />
			<param index="0" name="callback" type="Callable" />
			<description>
				Creates and appends a [CallbackTweener]. This method can be used to call an arbitrary method in any object. Use [method Callable.bind] to bind additional arguments for the call.
				[b]Example:[/b] Object that keeps shooting every 1 second:
				[codeblocks]
				[gdscript]
				var tween = get_tree().create_tween().set_loops()
				tween.tween_callback(shoot).set_delay(1)
				[/gdscript]
				[csharp]
				Tween tween = GetTree().CreateTween().SetLoops();
				tween.TweenCallback(Callable.From(Shoot)).SetDelay(1.0f);
				[/csharp]
				[/codeblocks]
				[b]Example:[/b] Turning a sprite red and then blue, with 2 second delay:
				[codeblocks]
				[gdscript]
				var tween = get_tree().create_tween()
				tween.tween_callback($Sprite.set_modulate.bind(Color.RED)).set_delay(2)
				tween.tween_callback($Sprite.set_modulate.bind(Color.BLUE)).set_delay(2)
				[/gdscript]
				[csharp]
				Tween tween = GetTree().CreateTween();
				Sprite2D sprite = GetNode<Sprite2D>("Sprite");
				tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Red)).SetDelay(2.0f);
				tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Blue)).SetDelay(2.0f);
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="tween_interval">
			<return type="IntervalTweener" />
			<param index="0" name="time" type="float" />
			<description>
				Creates and appends an [IntervalTweener]. This method can be used to create delays in the tween animation, as an alternative to using the delay in other [Tweener]s, or when there's no animation (in which case the [Tween] acts as a timer). [param time] is the length of the interval, in seconds.
				[b]Example:[/b] Creating an interval in code execution:
				[codeblocks]
				[gdscript]
				# ... some code
				await create_tween().tween_interval(2).finished
				# ... more code
				[/gdscript]
				[csharp]
				// ... some code
				await ToSignal(CreateTween().TweenInterval(2.0f), Tween.SignalName.Finished);
				// ... more code
				[/csharp]
				[/codeblocks]
				[b]Example:[/b] Creating an object that moves back and forth and jumps every few seconds:
				[codeblocks]
				[gdscript]
				var tween = create_tween().set_loops()
				tween.tween_property($Sprite, "position:x", 200.0, 1).as_relative()
				tween.tween_callback(jump)
				tween.tween_interval(2)
				tween.tween_property($Sprite, "position:x", -200.0, 1).as_relative()
				tween.tween_callback(jump)
				tween.tween_interval(2)
				[/gdscript]
				[csharp]
				Tween tween = CreateTween().SetLoops();
				tween.TweenProperty(GetNode("Sprite"), "position:x", 200.0f, 1.0f).AsRelative();
				tween.TweenCallback(Callable.From(Jump));
				tween.TweenInterval(2.0f);
				tween.TweenProperty(GetNode("Sprite"), "position:x", -200.0f, 1.0f).AsRelative();
				tween.TweenCallback(Callable.From(Jump));
				tween.TweenInterval(2.0f);
				[/csharp]
				[/codeblocks]
			</description>
		</method>


<method name="tween_method">
			<return type="MethodTweener" />
			<param index="0" name="method" type="Callable" />
			<param index="1" name="from" type="Variant" />
			<param index="2" name="to" type="Variant" />
			<param index="3" name="duration" type="float" />
			<description>
				Creates and appends a [MethodTweener]. This method is similar to a combination of [method tween_callback] and [method tween_property]. It calls a method over time with a tweened value provided as an argument. The value is tweened between [param from] and [param to] over the time specified by [param duration], in seconds. Use [method Callable.bind] to bind additional arguments for the call. You can use [method MethodTweener.set_ease] and [method MethodTweener.set_trans] to tweak the easing and transition of the value or [method MethodTweener.set_delay] to delay the tweening.
				[b]Example:[/b] Making a 3D object look from one point to another point:
				[codeblocks]
				[gdscript]
				var tween = create_tween()
				tween.tween_method(look_at.bind(Vector3.UP), Vector3(-1, 0, -1), Vector3(1, 0, -1), 1) # The look_at() method takes up vector as second argument.
				[/gdscript]
				[csharp]
				Tween tween = CreateTween();
				tween.TweenMethod(Callable.From((Vector3 target) => LookAt(target, Vector3.Up)), new Vector3(-1.0f, 0.0f, -1.0f), new Vector3(1.0f, 0.0f, -1.0f), 1.0f); // Use lambdas to bind additional arguments for the call.
				[/csharp]
				[/codeblocks]
				[b]Example:[/b] Setting the text of a [Label], using an intermediate method and after a delay:
				[codeblocks]
				[gdscript]
				func _ready():
				    var tween = create_tween()
				    tween.tween_method(set_label_text, 0, 10, 1).set_delay(1)

				func set_label_text(value: int):
				    $Label.text = "Counting " + str(value)
				[/gdscript]
				[csharp]
				public override void _Ready()
				{
				    base._Ready();

				    Tween tween = CreateTween();
				    tween.TweenMethod(Callable.From<int>(SetLabelText), 0.0f, 10.0f, 1.0f).SetDelay(1.0f);
				}

				private void SetLabelText(int value)
				{
				    GetNode<Label>("Label").Text = $"Counting {value}";
				}
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="tween_property">
			<return type="PropertyTweener" />
			<param index="0" name="object" type="Object" />
			<param index="1" name="property" type="NodePath" />
			<param index="2" name="final_val" type="Variant" />
			<param index="3" name="duration" type="float" />
			<description>
				Creates and appends a [PropertyTweener]. This method tweens a [param property] of an [param object] between an initial value and [param final_val] in a span of time equal to [param duration], in seconds. The initial value by default is the property's value at the time the tweening of the [PropertyTweener] starts.
				[codeblocks]
				[gdscript]
				var tween = create_tween()
				tween.tween_property($Sprite, "position", Vector2(100, 200), 1)
				tween.tween_property($Sprite, "position", Vector2(200, 300), 1)
				[/gdscript]
				[csharp]
				Tween tween = CreateTween();
				tween.TweenProperty(GetNode("Sprite"), "position", new Vector2(100.0f, 200.0f), 1.0f);
				tween.TweenProperty(GetNode("Sprite"), "position", new Vector2(200.0f, 300.0f), 1.0f);
				[/csharp]
				[/codeblocks]
				will move the sprite to position (100, 200) and then to (200, 300). If you use [method PropertyTweener.from] or [method PropertyTweener.from_current], the starting position will be overwritten by the given value instead. See other methods in [PropertyTweener] to see how the tweening can be tweaked further.
				[b]Note:[/b] You can find the correct property name by hovering over the property in the Inspector. You can also provide the components of a property directly by using [code]"property:component"[/code] (eg. [code]position:x[/code]), where it would only apply to that particular component.
				[b]Example:[/b] Moving an object twice from the same position, with different transition types:
				[codeblocks]
				[gdscript]
				var tween = create_tween()
				tween.tween_property($Sprite, "position", Vector2.RIGHT * 300, 1).as_relative().set_trans(Tween.TRANS_SINE)
				tween.tween_property($Sprite, "position", Vector2.RIGHT * 300, 1).as_relative().from_current().set_trans(Tween.TRANS_EXPO)
				[/gdscript]
				[csharp]
				Tween tween = CreateTween();
				tween.TweenProperty(GetNode("Sprite"), "position", Vector2.Right * 300.0f, 1.0f).AsRelative().SetTrans(Tween.TransitionType.Sine);
				tween.TweenProperty(GetNode("Sprite"), "position", Vector2.Right * 300.0f, 1.0f).AsRelative().FromCurrent().SetTrans(Tween.TransitionType.Expo);
				[/csharp]
				[/codeblocks]
			</description>
		</method>
	</methods>
	<signals>
		<signal name="finished">
			<description>
				Emitted when the [Tween] has finished all tweening. Never emitted when the [Tween] is set to infinite looping (see [method set_loops]).
			</description>
		</signal>
		<signal name="loop_finished">
			<param index="0" name="loop_count" type="int" />
			<description>
				Emitted when a full loop is complete (see [method set_loops]), providing the loop index. This signal is not emitted after the final loop, use [signal finished] instead for this case.
			</description>
		</signal>
		<signal name="step_finished">
			<param index="0" name="idx" type="int" />
			<description>
				Emitted when one step of the [Tween] is complete, providing the step index. One step is either a single [Tweener] or a group of [Tweener]s running in parallel.
			</description>
		</signal>
	</signals>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="SubViewport" inherits="Viewport" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		An interface to a game world that doesn't create a window or draw to the screen directly.
	</brief_description>
	<description>
		[SubViewport] Isolates a rectangular region of a scene to be displayed independently. This can be used, for example, to display UI in 3D space.
		[b]Note:[/b] [SubViewport] is a [Viewport] that isn't a [Window], i.e. it doesn't draw anything by itself. To display anything, [SubViewport] must have a non-zero size and be either put inside a [SubViewportContainer] or assigned to a [ViewportTexture].
	</description>
	<tutorials>
		<link title="Using Viewports">$DOCS_URL/tutorials/rendering/viewports.html</link>
		<link title="Viewport and canvas transforms">$DOCS_URL/tutorials/2d/2d_transforms.html</link>
		<link title="GUI in 3D Viewport Demo">https://godotengine.org/asset-library/asset/2807</link>
		<link title="3D in 2D Viewport Demo">https://godotengine.org/asset-library/asset/2804</link>
		<link title="2D in 3D Viewport Demo">https://godotengine.org/asset-library/asset/2803</link>
		<link title="Screen Capture Demo">https://godotengine.org/asset-library/asset/2808</link>
		<link title="Dynamic Split Screen Demo">https://godotengine.org/asset-library/asset/2806</link>
		<link title="3D Resolution Scaling Demo">https://godotengine.org/asset-library/asset/2805</link>
	</tutorials>
	<members>
		<member name="render_target_clear_mode" type="int" setter="set_clear_mode" getter="get_clear_mode" enum="SubViewport.ClearMode" default="0">
			The clear mode when the sub-viewport is used as a render target.
			[b]Note:[/b] This property is intended for 2D usage.
		</member>
		<member name="render_target_update_mode" type="int" setter="set_update_mode" getter="get_update_mode" enum="SubViewport.UpdateMode" default="2">
			The update mode when the sub-viewport is used as a render target.
		</member>
		<member name="size" type="Vector2i" setter="set_size" getter="get_size" default="Vector2i(512, 512)">
			The width and height of the sub-viewport. Must be set to a value greater than or equal to 2 pixels on both dimensions. Otherwise, nothing will be displayed.
			[b]Note:[/b] If the parent node is a [SubViewportContainer] and its [member SubViewportContainer.stretch] is [code]true[/code], the viewport size cannot be changed manually.
		</member>
		<member name="size_2d_override" type="Vector2i" setter="set_size_2d_override" getter="get_size_2d_override" default="Vector2i(0, 0)">
			The 2D size override of the sub-viewport. If either the width or height is [code]0[/code], the override is disabled.
		</member>
		<member name="size_2d_override_stretch" type="bool" setter="set_size_2d_override_stretch" getter="is_size_2d_override_stretch_enabled" default="false">
			If [code]true[/code], the 2D size override affects stretch as well.
		</member>
	</members>
	<constants>
		<constant name="CLEAR_MODE_ALWAYS" value="0" enum="ClearMode">
			Always clear the render target before drawing.
		</constant>
		<constant name="CLEAR_MODE_NEVER" value="1" enum="ClearMode">
			Never clear the render target.
		</constant>
		<constant name="CLEAR_MODE_ONCE" value="2" enum="ClearMode">
			Clear the render target on the next frame, then switch to [constant CLEAR_MODE_NEVER].
		</constant>
		<constant name="UPDATE_DISABLED" value="0" enum="UpdateMode">
			Do not update the render target.
		</constant>
		<constant name="UPDATE_ONCE" value="1" enum="UpdateMode">
			Update the render target once, then switch to [constant UPDATE_DISABLED].
		</constant>
		<constant name="UPDATE_WHEN_VISIBLE" value="2" enum="UpdateMode">
			Update the render target only when it is visible. This is the default value.
		</constant>
		<constant name="UPDATE_WHEN_PARENT_VISIBLE" value="3" enum="UpdateMode">
			Update the render target only when its parent is visible.
		</constant>
		<constant name="UPDATE_ALWAYS" value="4" enum="UpdateMode">
			Always update the render target.
		</constant>
	</constants>
</class>


<member name="transparency" type="int" setter="set_transparency" getter="get_transparency" enum="BaseMaterial3D.Transparency" default="0">
			The material's transparency mode. Some transparency modes will disable shadow casting. Any transparency mode other than [constant TRANSPARENCY_DISABLED] has a greater performance impact compared to opaque rendering. See also [member blend_mode].
		</member>
		<member name="use_particle_trails" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], enables parts of the shader required for [GPUParticles3D] trails to function. This also requires using a mesh with appropriate skinning, such as [RibbonTrailMesh] or [TubeTrailMesh]. Enabling this feature outside of materials used in [GPUParticles3D] meshes will break material rendering.
		</member>
		<member name="use_point_size" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], render point size can be changed.
			[b]Note:[/b] This is only effective for objects whose geometry is point-based rather than triangle-based. See also [member point_size].
		</member>
		<member name="uv1_offset" type="Vector3" setter="set_uv1_offset" getter="get_uv1_offset" default="Vector3(0, 0, 0)">
			How much to offset the [code]UV[/code] coordinates. This amount will be added to [code]UV[/code] in the vertex function. This can be used to offset a texture. The Z component is used when [member uv1_triplanar] is enabled, but it is not used anywhere else.
		</member>
		<member name="uv1_scale" type="Vector3" setter="set_uv1_scale" getter="get_uv1_scale" default="Vector3(1, 1, 1)">
			How much to scale the [code]UV[/code] coordinates. This is multiplied by [code]UV[/code] in the vertex function. The Z component is used when [member uv1_triplanar] is enabled, but it is not used anywhere else.
		</member>
		<member name="uv1_triplanar" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], instead of using [code]UV[/code] textures will use a triplanar texture lookup to determine how to apply textures. Triplanar uses the orientation of the object's surface to blend between texture coordinates. It reads from the source texture 3 times, once for each axis and then blends between the results based on how closely the pixel aligns with each axis. This is often used for natural features to get a realistic blend of materials. Because triplanar texturing requires many more texture reads per-pixel it is much slower than normal UV texturing. Additionally, because it is blending the texture between the three axes, it is unsuitable when you are trying to achieve crisp texturing.
		</member>
		<member name="uv1_triplanar_sharpness" type="float" setter="set_uv1_triplanar_blend_sharpness" getter="get_uv1_triplanar_blend_sharpness" default="1.0">
			A lower number blends the texture more softly while a higher number blends the texture more sharply.
			[b]Note:[/b] [member uv1_triplanar_sharpness] is clamped between [code]0.0[/code] and [code]150.0[/code] (inclusive) as values outside that range can look broken depending on the mesh.
		</member>
		<member name="uv1_world_triplanar" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], triplanar mapping for [code]UV[/code] is calculated in world space rather than object local space. See also [member uv1_triplanar].
		</member>
		<member name="uv2_offset" type="Vector3" setter="set_uv2_offset" getter="get_uv2_offset" default="Vector3(0, 0, 0)">
			How much to offset the [code]UV2[/code] coordinates. This amount will be added to [code]UV2[/code] in the vertex function. This can be used to offset a texture. The Z component is used when [member uv2_triplanar] is enabled, but it is not used anywhere else.
		</member>
		<member name="uv2_scale" type="Vector3" setter="set_uv2_scale" getter="get_uv2_scale" default="Vector3(1, 1, 1)">
			How much to scale the [code]UV2[/code] coordinates. This is multiplied by [code]UV2[/code] in the vertex function. The Z component is used when [member uv2_triplanar] is enabled, but it is not used anywhere else.
		</member>
		<member name="uv2_triplanar" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], instead of using [code]UV2[/code] textures will use a triplanar texture lookup to determine how to apply textures. Triplanar uses the orientation of the object's surface to blend between texture coordinates. It reads from the source texture 3 times, once for each axis and then blends between the results based on how closely the pixel aligns with each axis. This is often used for natural features to get a realistic blend of materials. Because triplanar texturing requires many more texture reads per-pixel it is much slower than normal UV texturing. Additionally, because it is blending the texture between the three axes, it is unsuitable when you are trying to achieve crisp texturing.
		</member>
		<member name="uv2_triplanar_sharpness" type="float" setter="set_uv2_triplanar_blend_sharpness" getter="get_uv2_triplanar_blend_sharpness" default="1.0">
			A lower number blends the texture more softly while a higher number blends the texture more sharply.
			[b]Note:[/b] [member uv2_triplanar_sharpness] is clamped between [code]0.0[/code] and [code]150.0[/code] (inclusive) as values outside that range can look broken depending on the mesh.
		</member>
		<member name="uv2_world_triplanar" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], triplanar mapping for [code]UV2[/code] is calculated in world space rather than object local space. See also [member uv2_triplanar].
		</member>
		<member name="vertex_color_is_srgb" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], vertex colors are considered to be stored in sRGB color space and are converted to linear color space during rendering. If [code]false[/code], vertex colors are considered to be stored in linear color space and are rendered as-is. See also [member albedo_texture_force_srgb].
			[b]Note:[/b] Only effective when using the Forward+ and Mobile rendering methods, not Compatibility.
		</member>
		<member name="vertex_color_use_as_albedo" type="bool" setter="set_flag" getter="get_flag" default="false">
			If [code]true[/code], the vertex color is used as albedo color.
		</member>
	</members>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="EditorImportPlugin" inherits="ResourceImporter" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		Registers a custom resource importer in the editor. Use the class to parse any file and import it as a new resource type.
	</brief_description>
	<description>
		[EditorImportPlugin]s provide a way to extend the editor's resource import functionality. Use them to import resources from custom files or to provide alternatives to the editor's existing importers.
		EditorImportPlugins work by associating with specific file extensions and a resource type. See [method _get_recognized_extensions] and [method _get_resource_type]. They may optionally specify some import presets that affect the import process. EditorImportPlugins are responsible for creating the resources and saving them in the [code].godot/imported[/code] directory (see [member ProjectSettings.application/config/use_hidden_project_data_directory]).
		Below is an example EditorImportPlugin that imports a [Mesh] from a file with the extension ".special" or ".spec":
		[codeblocks]
		[gdscript]
		@tool
		extends EditorImportPlugin

		func _get_importer_name():
		    return "my.special.plugin"

		func _get_visible_name():
		    return "Special Mesh"

		func _get_recognized_extensions():
		    return ["special", "spec"]

		func _get_save_extension():
		    return "mesh"

		func _get_resource_type():
		    return "Mesh"

		func _get_preset_count():
		    return 1

		func _get_preset_name(preset_index):
		    return "Default"

		func _get_import_options(path, preset_index):
		    return [{"name": "my_option", "default_value": false}]

		func _import(source_file, save_path, options, platform_variants, gen_files):
		    var file = FileAccess.open(source_file, FileAccess.READ)
		    if file == null:
		        return FAILED
		    var mesh = ArrayMesh.new()
		    # Fill the Mesh with data read in "file", left as an exercise to the reader.

		    var filename = save_path + "." + _get_save_extension()
		    return ResourceSaver.save(mesh, filename)
		[/gdscript]
		[csharp]
		using Godot;

		public partial class MySpecialPlugin : EditorImportPlugin
		{
		    public override string _GetImporterName()
		    {
		        return "my.special.plugin";
		    }

		    public override string _GetVisibleName()
		    {
		        return "Special Mesh";
		    }

		    public override string[] _GetRecognizedExtensions()
		    {
		        return new string[] { "special", "spec" };
		    }

		    public override string _GetSaveExtension()
		    {
		        return "mesh";
		    }

		    public override string _GetResourceType()
		    {
		        return "Mesh";
		    }

		    public override int _GetPresetCount()
		    {
		        return 1;
		    }

		    public override string _GetPresetName(int presetIndex)
		    {
		        return "Default";
		    }

		    public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetImportOptions(string path, int presetIndex)
		    {
		        return new Godot.Collections.Array<Godot.Collections.Dictionary>
		        {
		            new Godot.Collections.Dictionary
		            {
		                { "name", "myOption" },
		                { "default_value", false },
		            }
		        };
		    }

		    public override Error _Import(string sourceFile, string savePath, Godot.Collections.Dictionary options, Godot.Collections.Array<string> platformVariants, Godot.Collections.Array<string> genFiles)
		    {
		        using var file = FileAccess.Open(sourceFile, FileAccess.ModeFlags.Read);
		        if (file.GetError() != Error.Ok)
		        {
		            return Error.Failed;
		        }

		        var mesh = new ArrayMesh();
		        // Fill the Mesh with data read in "file", left as an exercise to the reader.
		        string filename = $"{savePath}.{_GetSaveExtension()}";
		        return ResourceSaver.Save(mesh, filename);
		    }
		}
		[/csharp]
		[/codeblocks]
		To use [EditorImportPlugin], register it using the [method EditorPlugin.add_import_plugin] method first.
	</description>
	<tutorials>
		<link title="Import plugins">$DOCS_URL/tutorials/plugins/editor/import_plugins.html</link>
	</tutorials>


<brief_description>
		Settings for a single tile in a [TileSet].
	</brief_description>
	<description>
		[TileData] object represents a single tile in a [TileSet]. It is usually edited using the tileset editor, but it can be modified at runtime using [method TileMap._tile_data_runtime_update].
	</description>
	<tutorials>
	</tutorials>
	<methods>
		<method name="add_collision_polygon">
			<return type="void" />
			<param index="0" name="layer_id" type="int" />
			<description>
				Adds a collision polygon to the tile on the given TileSet physics layer.
			</description>
		</method>
		<method name="add_occluder_polygon">
			<return type="void" />
			<param index="0" name="layer_id" type="int" />
			<description>
				Adds an occlusion polygon to the tile on the TileSet occlusion layer with index [param layer_id].
			</description>
		</method>
		<method name="get_collision_polygon_one_way_margin" qualifiers="const">
			<return type="float" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="polygon_index" type="int" />
			<description>
				Returns the one-way margin (for one-way platforms) of the polygon at index [param polygon_index] for TileSet physics layer with index [param layer_id].
			</description>
		</method>
		<method name="get_collision_polygon_points" qualifiers="const">
			<return type="PackedVector2Array" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="polygon_index" type="int" />
			<description>
				Returns the points of the polygon at index [param polygon_index] for TileSet physics layer with index [param layer_id].
			</description>
		</method>
		<method name="get_collision_polygons_count" qualifiers="const">
			<return type="int" />
			<param index="0" name="layer_id" type="int" />
			<description>
				Returns how many polygons the tile has for TileSet physics layer with index [param layer_id].
			</description>
		</method>
		<method name="get_constant_angular_velocity" qualifiers="const">
			<return type="float" />
			<param index="0" name="layer_id" type="int" />
			<description>
				Returns the constant angular velocity applied to objects colliding with this tile.
			</description>
		</method>
		<method name="get_constant_linear_velocity" qualifiers="const">
			<return type="Vector2" />
			<param index="0" name="layer_id" type="int" />
			<description>
				Returns the constant linear velocity applied to objects colliding with this tile.
			</description>
		</method>
		<method name="get_custom_data" qualifiers="const">
			<return type="Variant" />
			<param index="0" name="layer_name" type="String" />
			<description>
				Returns the custom data value for custom data layer named [param layer_name].
			</description>
		</method>
		<method name="get_custom_data_by_layer_id" qualifiers="const">
			<return type="Variant" />
			<param index="0" name="layer_id" type="int" />
			<description>
				Returns the custom data value for custom data layer with index [param layer_id].
			</description>
		</method>
		<method name="get_navigation_polygon" qualifiers="const">
			<return type="NavigationPolygon" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="flip_h" type="bool" default="false" />
			<param index="2" name="flip_v" type="bool" default="false" />
			<param index="3" name="transpose" type="bool" default="false" />
			<description>
				Returns the navigation polygon of the tile for the TileSet navigation layer with index [param layer_id].
				[param flip_h], [param flip_v], and [param transpose] allow transforming the returned polygon.
			</description>
		</method>
		<method name="get_occluder" qualifiers="const" deprecated="Use [method get_occluder_polygon] instead.">
			<return type="OccluderPolygon2D" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="flip_h" type="bool" default="false" />
			<param index="2" name="flip_v" type="bool" default="false" />
			<param index="3" name="transpose" type="bool" default="false" />
			<description>
				Returns the occluder polygon of the tile for the TileSet occlusion layer with index [param layer_id].
				[param flip_h], [param flip_v], and [param transpose] allow transforming the returned polygon.
			</description>
		</method>
		<method name="get_occluder_polygon" qualifiers="const">
			<return type="OccluderPolygon2D" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="polygon_index" type="int" />
			<param index="2" name="flip_h" type="bool" default="false" />
			<param index="3" name="flip_v" type="bool" default="false" />
			<param index="4" name="transpose" type="bool" default="false" />
			<description>
				Returns the occluder polygon at index [param polygon_index] from the TileSet occlusion layer with index [param layer_id].
				The [param flip_h], [param flip_v], and [param transpose] parameters can be [code]true[/code] to transform the returned polygon.
			</description>
		</method>
		<method name="get_occluder_polygons_count" qualifiers="const">
			<return type="int" />
			<param index="0" name="layer_id" type="int" />
			<description>
				Returns the number of occluder polygons of the tile in the TileSet occlusion layer with index [param layer_id].
			</description>
		</method>
		<method name="get_terrain_peering_bit" qualifiers="const">
			<return type="int" />
			<param index="0" name="peering_bit" type="int" enum="TileSet.CellNeighbor" />
			<description>
				Returns the tile's terrain bit for the given [param peering_bit] direction. To check that a direction is valid, use [method is_valid_terrain_peering_bit].
			</description>
		</method>
		<method name="is_collision_polygon_one_way" qualifiers="const">
			<return type="bool" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="polygon_index" type="int" />
			<description>
				Returns whether one-way collisions are enabled for the polygon at index [param polygon_index] for TileSet physics layer with index [param layer_id].
			</description>
		</method>
		<method name="is_valid_terrain_peering_bit" qualifiers="const">
			<return type="bool" />
			<param index="0" name="peering_bit" type="int" enum="TileSet.CellNeighbor" />
			<description>
				Returns whether the given [param peering_bit] direction is valid for this tile.
			</description>
		</method>
		<method name="remove_collision_polygon">
			<return type="void" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="polygon_index" type="int" />
			<description>
				Removes the polygon at index [param polygon_index] for TileSet physics layer with index [param layer_id].
			</description>
		</method>
		<method name="remove_occluder_polygon">
			<return type="void" />
			<param index="0" name="layer_id" type="int" />
			<param index="1" name="polygon_index" type="int" />
			<description>
				Removes the polygon at index [param polygon_index] for TileSet occlusion layer with index [param layer_id].
			</description>
		</method>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="ResourceLoader" inherits="Object" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A singleton for loading resource files.
	</brief_description>
	<description>
		A singleton used to load resource files from the filesystem.
		It uses the many [ResourceFormatLoader] classes registered in the engine (either built-in or from a plugin) to load files into memory and convert them to a format that can be used by the engine.
		[b]Note:[/b] You have to import the files into the engine first to load them using [method load]. If you want to load [Image]s at run-time, you may use [method Image.load]. If you want to import audio files, you can use the snippet described in [member AudioStreamMP3.data].
	</description>
	<tutorials>
		<link title="Operating System Testing Demo">https://godotengine.org/asset-library/asset/2789</link>
	</tutorials>


<methods>
		<method name="add_resource_format_loader">
			<return type="void" />
			<param index="0" name="format_loader" type="ResourceFormatLoader" />
			<param index="1" name="at_front" type="bool" default="false" />
			<description>
				Registers a new [ResourceFormatLoader]. The ResourceLoader will use the ResourceFormatLoader as described in [method load].
				This method is performed implicitly for ResourceFormatLoaders written in GDScript (see [ResourceFormatLoader] for more information).
			</description>
		</method>
		<method name="exists">
			<return type="bool" />
			<param index="0" name="path" type="String" />
			<param index="1" name="type_hint" type="String" default="""" />
			<description>
				Returns whether a recognized resource exists for the given [param path].
				An optional [param type_hint] can be used to further specify the [Resource] type that should be handled by the [ResourceFormatLoader]. Anything that inherits from [Resource] can be used as a type hint, for example [Image].
				[b]Note:[/b] If you use [method Resource.take_over_path], this method will return [code]true[/code] for the taken path even if the resource wasn't saved (i.e. exists only in resource cache).
			</description>
		</method>
		<method name="get_cached_ref">
			<return type="Resource" />
			<param index="0" name="path" type="String" />
			<description>
				Returns the cached resource reference for the given [param path].
				[b]Note:[/b] If the resource is not cached, the returned [Resource] will be invalid.
			</description>
		</method>
		<method name="get_dependencies">
			<return type="PackedStringArray" />
			<param index="0" name="path" type="String" />
			<description>
				Returns the dependencies for the resource at the given [param path].
				[b]Note:[/b] The dependencies are returned with slices separated by [code]::[/code]. You can use [method String.get_slice] to get their components.
				[codeblock]
				for dep in ResourceLoader.get_dependencies(path):
				    print(dep.get_slice("::", 0)) # Prints UID.
				    print(dep.get_slice("::", 2)) # Prints path.
				[/codeblock]
			</description>
		</method>
		<method name="get_recognized_extensions_for_type">
			<return type="PackedStringArray" />
			<param index="0" name="type" type="String" />
			<description>
				Returns the list of recognized extensions for a resource type.
			</description>
		</method>
		<method name="get_resource_uid">
			<return type="int" />
			<param index="0" name="path" type="String" />
			<description>
				Returns the ID associated with a given resource path, or [code]-1[/code] when no such ID exists.
			</description>
		</method>
		<method name="has_cached">
			<return type="bool" />
			<param index="0" name="path" type="String" />
			<description>
				Returns whether a cached resource is available for the given [param path].
				Once a resource has been loaded by the engine, it is cached in memory for faster access, and future calls to the [method load] method will use the cached version. The cached resource can be overridden by using [method Resource.take_over_path] on a new resource for that same path.
			</description>
		</method>
		<method name="load">
			<return type="Resource" />
			<param index="0" name="path" type="String" />
			<param index="1" name="type_hint" type="String" default="""" />
			<param index="2" name="cache_mode" type="int" enum="ResourceLoader.CacheMode" default="1" />
			<description>
				Loads a resource at the given [param path], caching the result for further access.
				The registered [ResourceFormatLoader]s are queried sequentially to find the first one which can handle the file's extension, and then attempt loading. If loading fails, the remaining ResourceFormatLoaders are also attempted.
				An optional [param type_hint] can be used to further specify the [Resource] type that should be handled by the [ResourceFormatLoader]. Anything that inherits from [Resource] can be used as a type hint, for example [Image].
				The [param cache_mode] property defines whether and how the cache should be used or updated when loading the resource. See [enum CacheMode] for details.
				Returns an empty resource if no [ResourceFormatLoader] could handle the file, and prints an error if no file is found at the specified path.
				GDScript has a simplified [method @GDScript.load] built-in method which can be used in most situations, leaving the use of [ResourceLoader] for more advanced scenarios.
				[b]Note:[/b] If [member ProjectSettings.editor/export/convert_text_resources_to_binary] is [code]true[/code], [method @GDScript.load] will not be able to read converted files in an exported project. If you rely on run-time loading of files present within the PCK, set [member ProjectSettings.editor/export/convert_text_resources_to_binary] to [code]false[/code].
				[b]Note:[/b] Relative paths will be prefixed with [code]"res://"[/code] before loading, to avoid unexpected results make sure your paths are absolute.
			</description>
		</method>
		<method name="load_threaded_get">
			<return type="Resource" />
			<param index="0" name="path" type="String" />
			<description>
				Returns the resource loaded by [method load_threaded_request].
				If this is called before the loading thread is done (i.e. [method load_threaded_get_status] is not [constant THREAD_LOAD_LOADED]), the calling thread will be blocked until the resource has finished loading. However, it's recommended to use [method load_threaded_get_status] to known when the load has actually completed.
			</description>
		</method>
		<method name="load_threaded_get_status">
			<return type="int" enum="ResourceLoader.ThreadLoadStatus" />
			<param index="0" name="path" type="String" />
			<param index="1" name="progress" type="Array" default="[]" />
			<description>
				Returns the status of a threaded loading operation started with [method load_threaded_request] for the resource at [param path]. See [enum ThreadLoadStatus] for possible return values.
				An array variable can optionally be passed via [param progress], and will return a one-element array containing the percentage of completion of the threaded loading.
				[b]Note:[/b] The recommended way of using this method is to call it during different frames (e.g., in [method Node._process], instead of a loop).
			</description>
		</method>
		<method name="load_threaded_request">
			<return type="int" enum="Error" />
			<param index="0" name="path" type="String" />
			<param index="1" name="type_hint" type="String" default="""" />
			<param index="2" name="use_sub_threads" type="bool" default="false" />
			<param index="3" name="cache_mode" type="int" enum="ResourceLoader.CacheMode" default="1" />
			<description>
				Loads the resource using threads. If [param use_sub_threads] is [code]true[/code], multiple threads will be used to load the resource, which makes loading faster, but may affect the main thread (and thus cause game slowdowns).
				The [param cache_mode] property defines whether and how the cache should be used or updated when loading the resource. See [enum CacheMode] for details.
			</description>
		</method>
		<method name="remove_resource_format_loader">
			<return type="void" />
			<param index="0" name="format_loader" type="ResourceFormatLoader" />
			<description>
				Unregisters the given [ResourceFormatLoader].
			</description>
		</method>
		<method name="set_abort_on_missing_resources">
			<return type="void" />
			<param index="0" name="abort" type="bool" />
			<description>
				Changes the behavior on missing sub-resources. The default behavior is to abort loading.
			</description>
		</method>
	</methods>


<constants>
		<constant name="THREAD_LOAD_INVALID_RESOURCE" value="0" enum="ThreadLoadStatus">
			The resource is invalid, or has not been loaded with [method load_threaded_request].
		</constant>
		<constant name="THREAD_LOAD_IN_PROGRESS" value="1" enum="ThreadLoadStatus">
			The resource is still being loaded.
		</constant>
		<constant name="THREAD_LOAD_FAILED" value="2" enum="ThreadLoadStatus">
			Some error occurred during loading and it failed.
		</constant>
		<constant name="THREAD_LOAD_LOADED" value="3" enum="ThreadLoadStatus">
			The resource was loaded successfully and can be accessed via [method load_threaded_get].
		</constant>
		<constant name="CACHE_MODE_IGNORE" value="0" enum="CacheMode">
			Neither the main resource (the one requested to be loaded) nor any of its subresources are retrieved from cache nor stored into it. Dependencies (external resources) are loaded with [constant CACHE_MODE_REUSE].
		</constant>
		<constant name="CACHE_MODE_REUSE" value="1" enum="CacheMode">
			The main resource (the one requested to be loaded), its subresources, and its dependencies (external resources) are retrieved from cache if present, instead of loaded. Those not cached are loaded and then stored into the cache. The same rules are propagated recursively down the tree of dependencies (external resources).
		</constant>
		<constant name="CACHE_MODE_REPLACE" value="2" enum="CacheMode">
			Like [constant CACHE_MODE_REUSE], but the cache is checked for the main resource (the one requested to be loaded) as well as for each of its subresources. Those already in the cache, as long as the loaded and cached types match, have their data refreshed from storage into the already existing instances. Otherwise, they are recreated as completely new objects.
		</constant>
		<constant name="CACHE_MODE_IGNORE_DEEP" value="3" enum="CacheMode">
			Like [constant CACHE_MODE_IGNORE], but propagated recursively down the tree of dependencies (external resources).
		</constant>
		<constant name="CACHE_MODE_REPLACE_DEEP" value="4" enum="CacheMode">
			Like [constant CACHE_MODE_REPLACE], but propagated recursively down the tree of dependencies (external resources).
		</constant>
	</constants>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="Resource" inherits="RefCounted" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		Base class for serializable objects.
	</brief_description>
	<description>
		Resource is the base class for all Godot-specific resource types, serving primarily as data containers. Since they inherit from [RefCounted], resources are reference-counted and freed when no longer in use. They can also be nested within other resources, and saved on disk. [PackedScene], one of the most common [Object]s in a Godot project, is also a resource, uniquely capable of storing and instantiating the [Node]s it contains as many times as desired.
		In GDScript, resources can loaded from disk by their [member resource_path] using [method @GDScript.load] or [method @GDScript.preload].
		The engine keeps a global cache of all loaded resources, referenced by paths (see [method ResourceLoader.has_cached]). A resource will be cached when loaded for the first time and removed from cache once all references are released. When a resource is cached, subsequent loads using its path will return the cached reference.
		[b]Note:[/b] In C#, resources will not be freed instantly after they are no longer in use. Instead, garbage collection will run periodically and will free resources that are no longer in use. This means that unused resources will remain in memory for a while before being removed.
	</description>
	<tutorials>
		<link title="Resources">$DOCS_URL/tutorials/scripting/resources.html</link>
		<link title="When and how to avoid using nodes for everything">$DOCS_URL/tutorials/best_practices/node_alternatives.html</link>
	</tutorials>


<members>
		<member name="resource_local_to_scene" type="bool" setter="set_local_to_scene" getter="is_local_to_scene" default="false">
			If [code]true[/code], the resource is duplicated for each instance of all scenes using it. At run-time, the resource can be modified in one scene without affecting other instances (see [method PackedScene.instantiate]).
			[b]Note:[/b] Changing this property at run-time has no effect on already created duplicate resources.
		</member>
		<member name="resource_name" type="String" setter="set_name" getter="get_name" default="""">
			An optional name for this resource. When defined, its value is displayed to represent the resource in the Inspector dock. For built-in scripts, the name is displayed as part of the tab name in the script editor.
			[b]Note:[/b] Some resource formats do not support resource names. You can still set the name in the editor or via code, but it will be lost when the resource is reloaded. For example, only built-in scripts can have a resource name, while scripts stored in separate files cannot.
		</member>
		<member name="resource_path" type="String" setter="set_path" getter="get_path" default="""">
			The unique path to this resource. If it has been saved to disk, the value will be its filepath. If the resource is exclusively contained within a scene, the value will be the [PackedScene]'s filepath, followed by a unique identifier.
			[b]Note:[/b] Setting this property manually may fail if a resource with the same path has already been previously loaded. If necessary, use [method take_over_path].
		</member>
		<member name="resource_scene_unique_id" type="String" setter="set_scene_unique_id" getter="get_scene_unique_id">
			An unique identifier relative to the this resource's scene. If left empty, the ID is automatically generated when this resource is saved inside a [PackedScene]. If the resource is not inside a scene, this property is empty by default.
			[b]Note:[/b] When the [PackedScene] is saved, if multiple resources in the same scene use the same ID, only the earliest resource in the scene hierarchy keeps the original ID. The other resources are assigned new IDs from [method generate_scene_unique_id].
			[b]Note:[/b] Setting this property does not emit the [signal changed] signal.
			[b]Warning:[/b] When setting, the ID must only consist of letters, numbers, and underscores. Otherwise, it will fail and default to a randomly generated ID.
		</member>
	</members>
	<signals>
		<signal name="changed">
			<description>
				Emitted when the resource changes, usually when one of its properties is modified. See also [method emit_changed].
				[b]Note:[/b] This signal is not emitted automatically for properties of custom resources. If necessary, a setter needs to be created to emit the signal.
			</description>
		</signal>
		<signal name="setup_local_to_scene_requested" deprecated="This signal is only emitted when the resource is created. Override [method _setup_local_to_scene] instead.">
			<description>
				Emitted by a newly duplicated resource with [member resource_local_to_scene] set to [code]true[/code].
			</description>
		</signal>
	</signals>
</class>


method name="_has_main_screen" qualifiers="virtual const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if this is a main screen editor plugin (it goes in the workspace selector together with [b]2D[/b], [b]3D[/b], [b]Script[/b] and [b]AssetLib[/b]).
				When the plugin's workspace is selected, other main screen plugins will be hidden, but your plugin will not appear automatically. It needs to be added as a child of [method EditorInterface.get_editor_main_screen] and made visible inside [method _make_visible].
				Use [method _get_plugin_name] and [method _get_plugin_icon] to customize the plugin button's appearance.
				[codeblock]
				var plugin_control

				func _enter_tree():
				    plugin_control = preload("my_plugin_control.tscn").instantiate()
				    EditorInterface.get_editor_main_screen().add_child(plugin_control)
				    plugin_control.hide()

				func _has_main_screen():
				    return true

				func _make_visible(visible):
				    plugin_control.visible = visible

				func _get_plugin_name():
				    return "My Super Cool Plugin 3000"

				func _get_plugin_icon():
				    return EditorInterface.get_editor_theme().get_icon("Node", "EditorIcons")
				[/codeblock]
			</description>
		</method>
		<method name="_make_visible" qualifiers="virtual">
			<return type="void" />
			<param index="0" name="visible" type="bool" />
			<description>
				This function will be called when the editor is requested to become visible. It is used for plugins that edit a specific object type.
				Remember that you have to manage the visibility of all your editor controls manually.
			</description>
		</method>
		<method name="_save_external_data" qualifiers="virtual">
			<return type="void" />
			<description>
				This method is called after the editor saves the project or when it's closed. It asks the plugin to save edited external scenes/resources.
			</description>
		</method>
		<method name="_set_state" qualifiers="virtual">
			<return type="void" />
			<param index="0" name="state" type="Dictionary" />
			<description>
				Restore the state saved by [method _get_state]. This method is called when the current scene tab is changed in the editor.
				[b]Note:[/b] Your plugin must implement [method _get_plugin_name], otherwise it will not be recognized and this method will not be called.
				[codeblock]
				func _set_state(data):
				    zoom = data.get("zoom", 1.0)
				    preferred_color = data.get("my_color", Color.WHITE)
				[/codeblock]
			</description>
		</method>
		<method name="_set_window_layout" qualifiers="virtual">
			<return type="void" />
			<param index="0" name="configuration" type="ConfigFile" />
			<description>
				Restore the plugin GUI layout and data saved by [method _get_window_layout]. This method is called for every plugin on editor startup. Use the provided [param configuration] file to read your saved data.
				[codeblock]
				func _set_window_layout(configuration):
				    $Window.position = configuration.get_value("MyPlugin", "window_position", Vector2())
				    $Icon.modulate = configuration.get_value("MyPlugin", "icon_color", Color.WHITE)
				[/codeblock]
			</description>
		</method>
		<method name="add_autoload_singleton">
			<return type="void" />
			<param index="0" name="name" type="String" />
			<param index="1" name="path" type="String" />
			<description>
				Adds a script at [param path] to the Autoload list as [param name].
			</description>
		</method>
		<method name="add_context_menu_plugin">
			<return type="void" />
			<param index="0" name="slot" type="int" enum="EditorContextMenuPlugin.ContextMenuSlot" />
			<param index="1" name="plugin" type="EditorContextMenuPlugin" />
			<description>
				Adds a plugin to the context menu. [param slot] is the context menu where the plugin will be added.
				See [enum EditorContextMenuPlugin.ContextMenuSlot] for available context menus. A plugin instance can belong only to a single context menu slot.
			</description>
		</method>
		<method name="add_control_to_bottom_panel">
			<return type="Button" />
			<param index="0" name="control" type="Control" />
			<param index="1" name="title" type="String" />
			<param index="2" name="shortcut" type="Shortcut" default="null" />
			<description>
				Adds a control to the bottom panel (together with Output, Debug, Animation, etc). Returns a reference to the button added. It's up to you to hide/show the button when needed. When your plugin is deactivated, make sure to remove your custom control with [method remove_control_from_bottom_panel] and free it with [method Node.queue_free].
				Optionally, you can specify a shortcut parameter. When pressed, this shortcut will toggle the bottom panel's visibility. See the default editor bottom panel shortcuts in the Editor Settings for inspiration. Per convention, they all use [kbd]Alt[/kbd] modifier.
			</description>
		</method>
		<method name="add_control_to_container">
			<return type="void" />
			<param index="0" name="container" type="int" enum="EditorPlugin.CustomControlContainer" />
			<param index="1" name="control" type="Control" />
			<description>
				Adds a custom control to a container (see [enum CustomControlContainer]). There are many locations where custom controls can be added in the editor UI.
				Please remember that you have to manage the visibility of your custom controls yourself (and likely hide it after adding it).
				When your plugin is deactivated, make sure to remove your custom control with [method remove_control_from_container] and free it with [method Node.queue_free].
			</description>
		</method>
		<method name="add_control_to_dock">
			<return type="void" />
			<param index="0" name="slot" type="int" enum="EditorPlugin.DockSlot" />
			<param index="1" name="control" type="Control" />
			<param index="2" name="shortcut" type="Shortcut" default="null" />
			<description>
				Adds the control to a specific dock slot (see [enum DockSlot] for options).
				If the dock is repositioned and as long as the plugin is active, the editor will save the dock position on further sessions.
				When your plugin is deactivated, make sure to remove your custom control with [method remove_control_from_docks] and free it with [method Node.queue_free].
				Optionally, you can specify a shortcut parameter. When pressed, this shortcut will toggle the dock's visibility once it's moved to the bottom panel (this shortcut does not affect the dock otherwise). See the default editor bottom panel shortcuts in the Editor Settings for inspiration. Per convention, they all use [kbd]Alt[/kbd] modifier.
			</description>
		</method>
		<method name="add_custom_type">
			<return type="void" />
			<param index="0" name="type" type="String" />
			<param index="1" name="base" type="String" />
			<param index="2" name="script" type="Script" />
			<param index="3" name="icon" type="Texture2D" />
			<description>
				Adds a custom type, which will appear in the list of nodes or resources.
				When a given node or resource is selected, the base type will be instantiated (e.g. "Node3D", "Control", "Resource"), then the script will be loaded and set to this object.
				[b]Note:[/b] The base type is the base engine class which this type's class hierarchy inherits, not any custom type parent classes.
				You can use the virtual method [method _handles] to check if your custom object is being edited by checking the script or using the [code]is[/code] keyword.
				During run-time, this will be a simple object with a script so this function does not need to be called then.
				[b]Note:[/b] Custom types added this way are not true classes. They are just a helper to create a node with specific script.
			</description>
		</method>
		<