<methods>
		<method name="apply_floor_snap">
			<return type="void" />
			<description>
				Allows to manually apply a snap to the floor regardless of the body's velocity. This function does nothing when [method is_on_floor] returns [code]true[/code].
			</description>
		</method>
		<method name="get_floor_angle" qualifiers="const">
			<return type="float" />
			<param index="0" name="up_direction" type="Vector3" default="Vector3(0, 1, 0)" />
			<description>
				Returns the floor's collision angle at the last collision point according to [param up_direction], which is [constant Vector3.UP] by default. This value is always positive and only valid after calling [method move_and_slide] and when [method is_on_floor] returns [code]true[/code].
			</description>
		</method>
		<method name="get_floor_normal" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the collision normal of the floor at the last collision point. Only valid after calling [method move_and_slide] and when [method is_on_floor] returns [code]true[/code].
				[b]Warning:[/b] The collision normal is not always the same as the surface normal.
			</description>
		</method>
		<method name="get_last_motion" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the last motion applied to the [CharacterBody3D] during the last call to [method move_and_slide]. The movement can be split into multiple motions when sliding occurs, and this method return the last one, which is useful to retrieve the current direction of the movement.
			</description>
		</method>
		<method name="get_last_slide_collision">
			<return type="KinematicCollision3D" />
			<description>
				Returns a [KinematicCollision3D], which contains information about the latest collision that occurred during the last call to [method move_and_slide].
			</description>
		</method>
		<method name="get_platform_angular_velocity" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the angular velocity of the platform at the last collision point. Only valid after calling [method move_and_slide].
			</description>
		</method>
		<method name="get_platform_velocity" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the linear velocity of the platform at the last collision point. Only valid after calling [method move_and_slide].
			</description>
		</method>
		<method name="get_position_delta" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the travel (position delta) that occurred during the last call to [method move_and_slide].
			</description>
		</method>
		<method name="get_real_velocity" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the current real velocity since the last call to [method move_and_slide]. For example, when you climb a slope, you will move diagonally even though the velocity is horizontal. This method returns the diagonal movement, as opposed to [member velocity] which returns the requested velocity.
			</description>
		</method>
		<method name="get_slide_collision">
			<return type="KinematicCollision3D" />
			<param index="0" name="slide_idx" type="int" />
			<description>
				Returns a [KinematicCollision3D], which contains information about a collision that occurred during the last call to [method move_and_slide]. Since the body can collide several times in a single call to [method move_and_slide], you must specify the index of the collision in the range 0 to ([method get_slide_collision_count] - 1).
			</description>
		</method>
		<method name="get_slide_collision_count" qualifiers="const">
			<return type="int" />
			<description>
				Returns the number of times the body collided and changed direction during the last call to [method move_and_slide].
			</description>
		</method>
		<method name="get_wall_normal" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the collision normal of the wall at the last collision point. Only valid after calling [method move_and_slide] and when [method is_on_wall] returns [code]true[/code].
				[b]Warning:[/b] The collision normal is not always the same as the surface normal.
			</description>
		</method>
		<method name="is_on_ceiling" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided with the ceiling on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "ceiling" or not.
			</description>
		</method>
		<method name="is_on_ceiling_only" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided only with the ceiling on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "ceiling" or not.
			</description>
		</method>
		<method name="is_on_floor" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided with the floor on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "floor" or not.
			</description>
		</method>
		<method name="is_on_floor_only" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided only with the floor on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "floor" or not.
			</description>
		</method>
		<method name="is_on_wall" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided with a wall on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "wall" or not.
			</description>
		</method>
		<method name="is_on_wall_only" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided only with a wall on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "wall" or not.
			</description>
		</method>
		<method name="move_and_slide">
			<return type="bool" />
			<description>
				Moves the body based on [member velocity]. If the body collides with another, it will slide along the other body rather than stop immediately. If the other body is a [CharacterBody3D] or [RigidBody3D], it will also be affected by the motion of the other body. You can use this to make moving and rotating platforms, or to make nodes push other nodes.
				Modifies [member velocity] if a slide collision occurred. To get the latest collision call [method get_last_slide_collision], for more detailed information about collisions that occurred, use [method get_slide_collision].
				When the body touches a moving platform, the platform's velocity is automatically added to the body motion. If a collision occurs due to the platform's motion, it will always be first in the slide collisions.
				Returns [code]true[/code] if the body collided, otherwise, returns [code]false[/code].
			</description>
		</method>
	</methods>


<members>
		<member name="floor_block_on_wall" type="bool" setter="set_floor_block_on_wall_enabled" getter="is_floor_block_on_wall_enabled" default="true">
			If [code]true[/code], the body will be able to move on the floor only. This option avoids to be able to walk on walls, it will however allow to slide down along them.
		</member>
		<member name="floor_constant_speed" type="bool" setter="set_floor_constant_speed_enabled" getter="is_floor_constant_speed_enabled" default="false">
			If [code]false[/code] (by default), the body will move faster on downward slopes and slower on upward slopes.
			If [code]true[/code], the body will always move at the same speed on the ground no matter the slope. Note that you need to use [member floor_snap_length] to stick along a downward slope at constant speed.
		</member>
		<member name="floor_max_angle" type="float" setter="set_floor_max_angle" getter="get_floor_max_angle" default="0.785398">
			Maximum angle (in radians) where a slope is still considered a floor (or a ceiling), rather than a wall, when calling [method move_and_slide]. The default value equals 45 degrees.
		</member>
		<member name="floor_snap_length" type="float" setter="set_floor_snap_length" getter="get_floor_snap_length" default="0.1">
			Sets a snapping distance. When set to a value different from [code]0.0[/code], the body is kept attached to slopes when calling [method move_and_slide]. The snapping vector is determined by the given distance along the opposite direction of the [member up_direction].
			As long as the snapping vector is in contact with the ground and the body moves against [member up_direction], the body will remain attached to the surface. Snapping is not applied if the body moves along [member up_direction], meaning it contains vertical rising velocity, so it will be able to detach from the ground when jumping or when the body is pushed up by something. If you want to apply a snap without taking into account the velocity, use [method apply_floor_snap].
		</member>
		<member name="floor_stop_on_slope" type="bool" setter="set_floor_stop_on_slope_enabled" getter="is_floor_stop_on_slope_enabled" default="true">
			If [code]true[/code], the body will not slide on slopes when calling [method move_and_slide] when the body is standing still.
			If [code]false[/code], the body will slide on floor's slopes when [member velocity] applies a downward force.
		</member>
		<member name="max_slides" type="int" setter="set_max_slides" getter="get_max_slides" default="6">
			Maximum number of times the body can change direction before it stops when calling [method move_and_slide].
		</member>
		<member name="motion_mode" type="int" setter="set_motion_mode" getter="get_motion_mode" enum="CharacterBody3D.MotionMode" default="0">
			Sets the motion mode which defines the behavior of [method move_and_slide]. See [enum MotionMode] constants for available modes.
		</member>
		<member name="platform_floor_layers" type="int" setter="set_platform_floor_layers" getter="get_platform_floor_layers" default="4294967295">
			Collision layers that will be included for detecting floor bodies that will act as moving platforms to be followed by the [CharacterBody3D]. By default, all floor bodies are detected and propagate their velocity.
		</member>
		<member name="platform_on_leave" type="int" setter="set_platform_on_leave" getter="get_platform_on_leave" enum="CharacterBody3D.PlatformOnLeave" default="0">
			Sets the behavior to apply when you leave a moving platform. By default, to be physically accurate, when you leave the last platform velocity is applied. See [enum PlatformOnLeave] constants for available behavior.
		</member>
		<member name="platform_wall_layers" type="int" setter="set_platform_wall_layers" getter="get_platform_wall_layers" default="0">
			Collision layers that will be included for detecting wall bodies that will act as moving platforms to be followed by the [CharacterBody3D]. By default, all wall bodies are ignored.
		</member>
		<member name="safe_margin" type="float" setter="set_safe_margin" getter="get_safe_margin" default="0.001">
			Extra margin used for collision recovery when calling [method move_and_slide].
			If the body is at least this close to another body, it will consider them to be colliding and will be pushed away before performing the actual motion.
			A higher value means it's more flexible for detecting collision, which helps with consistently detecting walls and floors.
			A lower value forces the collision algorithm to use more exact detection, so it can be used in cases that specifically require precision, e.g at very low scale to avoid visible jittering, or for stability with a stack of character bodies.
		</member>
		<member name="slide_on_ceiling" type="bool" setter="set_slide_on_ceiling_enabled" getter="is_slide_on_ceiling_enabled" default="true">
			If [code]true[/code], during a jump against the ceiling, the body will slide, if [code]false[/code] it will be stopped and will fall vertically.
		</member>
		<member name="up_direction" type="Vector3" setter="set_up_direction" getter="get_up_direction" default="Vector3(0, 1, 0)">
			Vector pointing upwards, used to determine what is a wall and what is a floor (or a ceiling) when calling [method move_and_slide]. Defaults to [constant Vector3.UP]. As the vector will be normalized it can't be equal to [constant Vector3.ZERO], if you want all collisions to be reported as walls, consider using [constant MOTION_MODE_FLOATING] as [member motion_mode].
		</member>
		<member name="velocity" type="Vector3" setter="set_velocity" getter="get_velocity" default="Vector3(0, 0, 0)">
			Current velocity vector (typically meters per second), used and modified during calls to [method move_and_slide].
		</member>
		<member name="wall_min_slide_angle" type="float" setter="set_wall_min_slide_angle" getter="get_wall_min_slide_angle" default="0.261799">
			Minimum angle (in radians) where the body is allowed to slide when it encounters a slope. The default value equals 15 degrees. When [member motion_mode] is [constant MOTION_MODE_GROUNDED], it only affects movement if [member floor_block_on_wall] is [code]true[/code].
		</member>
	</members>
	<constants>
		<constant name="MOTION_MODE_GROUNDED" value="0" enum="MotionMode">
			Apply when notions of walls, ceiling and floor are relevant. In this mode the body motion will react to slopes (acceleration/slowdown). This mode is suitable for grounded games like platformers.
		</constant>
		<constant name="MOTION_MODE_FLOATING" value="1" enum="MotionMode">
			Apply when there is no notion of floor or ceiling. All collisions will be reported as [code]on_wall[/code]. In this mode, when you slide, the speed will always be constant. This mode is suitable for games without ground like space games.
		</constant>
		<constant name="PLATFORM_ON_LEAVE_ADD_VELOCITY" value="0" enum="PlatformOnLeave">
			Add the last platform velocity to the [member velocity] when you leave a moving platform.
		</constant>
		<constant name="PLATFORM_ON_LEAVE_ADD_UPWARD_VELOCITY" value="1" enum="PlatformOnLeave">
			Add the last platform velocity to the [member velocity] when you leave a moving platform, but any downward motion is ignored. It's useful to keep full jump height even when the platform is moving down.
		</constant>
		<constant name="PLATFORM_ON_LEAVE_DO_NOTHING" value="2" enum="PlatformOnLeave">
			Do nothing when leaving a platform.
		</constant>
	</constants>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="Shape3D" inherits="Resource" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		Abstract base class for 3D shapes used for physics collision.
	</brief_description>
	<description>
		Abstract base class for all 3D shapes, intended for use in physics.
		[b]Performance:[/b] Primitive shapes, especially [SphereShape3D], are fast to check collisions against. [ConvexPolygonShape3D] and [HeightMapShape3D] are slower, and [ConcavePolygonShape3D] is the slowest.
	</description>
	<tutorials>
		<link title="Physics introduction">$DOCS_URL/tutorials/physics/physics_introduction.html</link>
	</tutorials>
	<methods>
		<method name="get_debug_mesh">
			<return type="ArrayMesh" />
			<description>
				Returns the [ArrayMesh] used to draw the debug collision for this [Shape3D].
			</description>
		</method>
	</methods>
	<members>
		<member name="custom_solver_bias" type="float" setter="set_custom_solver_bias" getter="get_custom_solver_bias" default="0.0">
			The shape's custom solver bias. Defines how much bodies react to enforce contact separation when this shape is involved.
			When set to [code]0[/code], the default value from [member ProjectSettings.physics/3d/solver/default_contact_bias] is used.
		</member>
		<member name="margin" type="float" setter="set_margin" getter="get_margin" default="0.04">
			The collision margin for the shape. This is not used in Godot Physics.
			Collision margins allow collision detection to be more efficient by adding an extra shell around shapes. Collision algorithms are more expensive when objects overlap by more than their margin, so a higher value for margins is better for performance, at the cost of accuracy around edges as it makes them less sharp.
		</member>
	</members>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="PanelContainer" inherits="Container" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A container that keeps its child controls within the area of a [StyleBox].
	</brief_description>
	<description>
		A container that keeps its child controls within the area of a [StyleBox]. Useful for giving controls an outline.
	</description>
	<tutorials>
		<link title="Using Containers">$DOCS_URL/tutorials/ui/gui_containers.html</link>
		<link title="2D Role Playing Game (RPG) Demo">https://godotengine.org/asset-library/asset/2729</link>
	</tutorials>
	<members>
		<member name="mouse_filter" type="int" setter="set_mouse_filter" getter="get_mouse_filter" overrides="Control" enum="Control.MouseFilter" default="0" />
	</members>
	<theme_items>
		<theme_item name="panel" data_type="style" type="StyleBox">
			The style of [PanelContainer]'s background.
		</theme_item>
	</theme_items>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="RayCast3D" inherits="Node3D" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A ray in 3D space, used to find the first [CollisionObject3D] it intersects.
	</brief_description>
	<description>
		A raycast represents a ray from its origin to its [member target_position] that finds the closest [CollisionObject3D] along its path, if it intersects any.
		[RayCast3D] can ignore some objects by adding them to an exception list, by making its detection reporting ignore [Area3D]s ([member collide_with_areas]) or [PhysicsBody3D]s ([member collide_with_bodies]), or by configuring physics layers.
		[RayCast3D] calculates intersection every physics frame, and it holds the result until the next physics frame. For an immediate raycast, or if you want to configure a [RayCast3D] multiple times within the same physics frame, use [method force_raycast_update].
		To sweep over a region of 3D space, you can approximate the region with multiple [RayCast3D]s or use [ShapeCast3D].
	</description>
	<tutorials>
		<link title="Ray-casting">$DOCS_URL/tutorials/physics/ray-casting.html</link>
		<link title="3D Voxel Demo">https://godotengine.org/asset-library/asset/2755</link>
	</tutorials>
	<methods>
		<method name="add_exception">
			<return type="void" />
			<param index="0" name="node" type="CollisionObject3D" />
			<description>
				Adds a collision exception so the ray does not report collisions with the specified [CollisionObject3D] node.
			</description>
		</method>
		<method name="add_exception_rid">
			<return type="void" />
			<param index="0" name="rid" type="RID" />
			<description>
				Adds a collision exception so the ray does not report collisions with the specified [RID].
			</description>
		</method>
		<method name="clear_exceptions">
			<return type="void" />
			<description>
				Removes all collision exceptions for this ray.
			</description>
		</method>
		<method name="force_raycast_update">
			<return type="void" />
			<description>
				Updates the collision information for the ray immediately, without waiting for the next [code]_physics_process[/code] call. Use this method, for example, when the ray or its parent has changed state.
				[b]Note:[/b] [member enabled] does not need to be [code]true[/code] for this to work.
			</description>
		</method>
		<method name="get_collider" qualifiers="const">
			<return type="Object" />
			<description>
				Returns the first object that the ray intersects, or [code]null[/code] if no object is intersecting the ray (i.e. [method is_colliding] returns [code]false[/code]).
			</description>
		</method>
		<method name="get_collider_rid" qualifiers="const">
			<return type="RID" />
			<description>
				Returns the [RID] of the first object that the ray intersects, or an empty [RID] if no object is intersecting the ray (i.e. [method is_colliding] returns [code]false[/code]).
			</description>
		</method>
		<method name="get_collider_shape" qualifiers="const">
			<return type="int" />
			<description>
				Returns the shape ID of the first object that the ray intersects, or [code]0[/code] if no object is intersecting the ray (i.e. [method is_colliding] returns [code]false[/code]).
				To get the intersected shape node, for a [CollisionObject3D] target, use:
				[codeblocks]
				[gdscript]
				var target = get_collider() # A CollisionObject3D.
				var shape_id = get_collider_shape() # The shape index in the collider.
				var owner_id = target.shape_find_owner(shape_id) # The owner ID in the collider.
				var shape = target.shape_owner_get_owner(owner_id)
				[/gdscript]
				[csharp]
				var target = (CollisionObject3D)GetCollider(); // A CollisionObject3D.
				var shapeId = GetColliderShape(); // The shape index in the collider.
				var ownerId = target.ShapeFindOwner(shapeId); // The owner ID in the collider.
				var shape = target.ShapeOwnerGetOwner(ownerId);
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="get_collision_face_index" qualifiers="const">
			<return type="int" />
			<description>
				Returns the collision object's face index at the collision point, or [code]-1[/code] if the shape intersecting the ray is not a [ConcavePolygonShape3D].
			</description>
		</method>
		<method name="get_collision_mask_value" qualifiers="const">
			<return type="bool" />
			<param index="0" name="layer_number" type="int" />
			<description>
				Returns whether or not the specified layer of the [member collision_mask] is enabled, given a [param layer_number] between 1 and 32.
			</description>
		</method>
		<method name="get_collision_normal" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the normal of the intersecting object's shape at the collision point, or [code]Vector3(0, 0, 0)[/code] if the ray starts inside the shape and [member hit_from_inside] is [code]true[/code].
				[b]Note:[/b] Check that [method is_colliding] returns [code]true[/code] before calling this method to ensure the returned normal is valid and up-to-date.
			</description>
		</method>
		<method name="get_collision_point" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the collision point at which the ray intersects the closest object, in the global coordinate system. If [member hit_from_inside] is [code]true[/code] and the ray starts inside of a collision shape, this function will return the origin point of the ray.
				[b]Note:[/b] Check that [method is_colliding] returns [code]true[/code] before calling this method to ensure the returned point is valid and up-to-date.
			</description>
		</method>
		<method name="is_colliding" qualifiers="const">
			<return type="bool" />
			<description>
				Returns whether any object is intersecting with the ray's vector (considering the vector length).
			</description>
		</method>
		<method name="remove_exception">
			<return type="void" />
			<param index="0" name="node" type="CollisionObject3D" />
			<description>
				Removes a collision exception so the ray does report collisions with the specified [CollisionObject3D] node.
			</description>
		</method>
		<method name="remove_exception_rid">
			<return type="void" />
			<param index="0" name="rid" type="RID" />
			<description>
				Removes a collision exception so the ray does report collisions with the specified [RID].
			</description>
		</method>
		<method name="set_collision_mask_value">
			<return type="void" />
			<param index="0" name="layer_number" type="int" />
			<param index="1" name="value" type="bool" />
			<description>
				Based on [param value], enables or disables the specified layer in the [member collision_mask], given a [param layer_number] between 1 and 32.
			</description>
		</method>
	</methods>


<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 [Area3D]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 [PhysicsBody3D]s will be reported.
		</member>
		<member name="collision_mask" type="int" setter="set_collision_mask" getter="get_collision_mask" default="1">
			The ray'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="debug_shape_custom_color" type="Color" setter="set_debug_shape_custom_color" getter="get_debug_shape_custom_color" default="Color(0, 0, 0, 1)">
			The custom color to use to draw the shape in the editor and at run-time if [b]Visible Collision Shapes[/b] is enabled in the [b]Debug[/b] menu. This color will be highlighted at run-time if the [RayCast3D] is colliding with something.
			If set to [code]Color(0.0, 0.0, 0.0)[/code] (by default), the color set in [member ProjectSettings.debug/shapes/collision/shape_color] is used.
		</member>
		<member name="debug_shape_thickness" type="int" setter="set_debug_shape_thickness" getter="get_debug_shape_thickness" default="2">
			If set to [code]1[/code], a line is used as the debug shape. Otherwise, a truncated pyramid is drawn to represent the [RayCast3D]. Requires [b]Visible Collision Shapes[/b] to be enabled in the [b]Debug[/b] menu for the debug shape to be visible at run-time.
		</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], collisions will be ignored for this RayCast3D's immediate parent.
		</member>
		<member name="hit_back_faces" type="bool" setter="set_hit_back_faces" getter="is_hit_back_faces_enabled" default="true">
			If [code]true[/code], the ray will hit back faces with concave polygon shapes with back face enabled or heightmap shapes.
		</member>
		<member name="hit_from_inside" type="bool" setter="set_hit_from_inside" getter="is_hit_from_inside_enabled" default="false">
			If [code]true[/code], the ray will detect a hit when starting inside shapes. In this case the collision normal will be [code]Vector3(0, 0, 0)[/code]. Does not affect shapes with no volume like concave polygon or heightmap.
		</member>
		<member name="target_position" type="Vector3" setter="set_target_position" getter="get_target_position" default="Vector3(0, -1, 0)">
			The ray's destination point, relative to the RayCast's [code]position[/code].
		</member>
	</members>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="VisualShaderNodeFloatParameter" inherits="VisualShaderNodeParameter" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A scalar float parameter to be used within the visual shader graph.
	</brief_description>
	<description>
		Translated to [code]uniform float[/code] in the shader language.
	</description>
	<tutorials>
	</tutorials>
	<members>
		<member name="default_value" type="float" setter="set_default_value" getter="get_default_value" default="0.0">
			A default value to be assigned within the shader.
		</member>
		<member name="default_value_enabled" type="bool" setter="set_default_value_enabled" getter="is_default_value_enabled" default="false">
			Enables usage of the [member default_value].
		</member>
		<member name="hint" type="int" setter="set_hint" getter="get_hint" enum="VisualShaderNodeFloatParameter.Hint" default="0">
			A hint applied to the uniform, which controls the values it can take when set through the Inspector.
		</member>
		<member name="max" type="float" setter="set_max" getter="get_max" default="1.0">
			Minimum value for range hints. Used if [member hint] is set to [constant HINT_RANGE] or [constant HINT_RANGE_STEP].
		</member>
		<member name="min" type="float" setter="set_min" getter="get_min" default="0.0">
			Maximum value for range hints. Used if [member hint] is set to [constant HINT_RANGE] or [constant HINT_RANGE_STEP].
		</member>
		<member name="step" type="float" setter="set_step" getter="get_step" default="0.1">
			Step (increment) value for the range hint with step. Used if [member hint] is set to [constant HINT_RANGE_STEP].
		</member>
	</members>
	<constants>
		<constant name="HINT_NONE" value="0" enum="Hint">
			No hint used.
		</constant>
		<constant name="HINT_RANGE" value="1" enum="Hint">
			A range hint for scalar value, which limits possible input values between [member min] and [member max]. Translated to [code]hint_range(min, max)[/code] in shader code.
		</constant>
		<constant name="HINT_RANGE_STEP" value="2" enum="Hint">
			A range hint for scalar value with step, which limits possible input values between [member min] and [member max], with a step (increment) of [member step]). Translated to [code]hint_range(min, max, step)[/code] in shader code.
		</constant>
		<constant name="HINT_MAX" value="3" enum="Hint">
			Represents the size of the [enum Hint] enum.
		</constant>
	</constants>
</class>


name="texture_proxy_create" deprecated="ProxyTexture was removed in Godot 4.">
			<return type="RID" />
			<param index="0" name="base" type="RID" />
			<description>
				This method does nothing and always returns an invalid [RID].
			</description>
		</method>
		<method name="texture_proxy_update" deprecated="ProxyTexture was removed in Godot 4.">
			<return type="void" />
			<param index="0" name="texture" type="RID" />
			<param index="1" name="proxy_to" type="RID" />
			<description>
				This method does nothing.
			</description>
		</method>
		<method name="texture_rd_create">
			<return type="RID" />
			<param index="0" name="rd_texture" type="RID" />
			<param index="1" name="layer_type" type="int" enum="RenderingServer.TextureLayeredType" default="0" />
			<description>
				Creates a new texture object based on a texture created directly on the [RenderingDevice]. If the texture contains layers, [param layer_type] is used to define the layer type.
			</description>
		</method>
		<method name="texture_replace">
			<return type="void" />
			<param index="0" name="texture" type="RID" />
			<param index="1" name="by_texture" type="RID" />
			<description>
				Replaces [param texture]'s texture data by the texture specified by the [param by_texture] RID, without changing [param texture]'s RID.
			</description>
		</method>
		<method name="texture_set_force_redraw_if_visible">
			<return type="void" />
			<param index="0" name="texture" type="RID" />
			<param index="1" name="enable" type="bool" />
			<description>
			</description>
		</method>
		<method name="texture_set_path">
			<return type="void" />
			<param index="0" name="texture" type="RID" />
			<param index="1" name="path" type="String" />
			<description>
			</description>
		</method>
		<method name="texture_set_size_override">
			<return type="void" />
			<param index="0" name="texture" type="RID" />
			<param index="1" name="width" type="int" />
			<param index="2" name="height" type="int" />
			<description>
			</description>
		</method>
		<method name="viewport_attach_camera">
			<return type="void" />
			<param index="0" name="viewport" type="RID" />
			<param index="1" name="camera" type="RID" />
			<description>
				Sets a viewport's camera.
			</description>
		</method>
		<method name="viewport_attach_canvas">
			<return type="void" />
			<param index="0" name="viewport" type="RID" />
			<param index="1" name="canvas" type="RID" />
			<description>
				Sets a viewport's canvas.
			</description>
		</method>
		<method name="viewport_attach_to_screen">
			<return type="void" />
			<param index="0" name="viewport" type="RID" />
			<param index="1" name="rect" type="Rect2" default="Rect2(0, 0, 0, 0)" />
			<param index="2" name="screen" type="int" default="0" />
			<description>
				Copies the viewport to a region of the screen specified by [param rect]. If [method viewport_set_render_direct_to_screen] is [code]true[/code], then the viewport does not use a framebuffer and the contents of the viewport are rendered directly to screen. However, note that the root viewport is drawn last, therefore it will draw over the screen. Accordingly, you must set the root viewport to an area that does not cover the area that you have attached this viewport to.
				For example, you can set the root viewport to not render at all with the following code:
				FIXME: The method seems to be non-existent.
				[codeblocks]
				[gdscript]
				func _ready():
				    get_viewport().set_attach_to_screen_rect(Rect2())
				    $Viewport.set_attach_to_screen_rect(Rect2(0, 0, 600, 600))
				[/gdscript]
				[/codeblocks]
				Using this can result in significant optimization, especially on lower-end devices. However, it comes at the cost of having to manage your viewports manually. For further optimization, see [method viewport_set_render_direct_to_screen].
			</description>
		</method>
		<method name="viewport_create">
			<return type="RID" />
			<description>
				Creates an empty viewport and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all [code]viewport_*[/code] RenderingServer functions.
				Once finished with your RID, you will want to free the RID using the RenderingServer's [method free_rid] method.
				[b]Note:[/b] The equivalent node is [Viewport].
			</description>
		</method>
		<method name="viewport_get_measured_render_time_cpu" qualifiers="const">
			<return type="float" />
			<param index="0" name="viewport" type="RID" />
			<description>
				Returns the CPU time taken to render the last frame in milliseconds. This [i]only[/i] includes time spent in rendering-related operations; scripts' [code]_process[/code] functions and other engine subsystems are not included in this readout. To get a complete readout of CPU time spent to render the scene, sum the render times of all viewports that are drawn every frame plus [method get_frame_setup_time_cpu]. Unlike [method Engine.get_frames_per_second], this method will accurately reflect CPU utilization even if framerate is capped via V-Sync or [member Engine.max_fps]. See also [method viewport_get_measured_render_time_gpu].
				[b]Note:[/b] Requires measurements to be enabled on the specified [param viewport] using [method viewport_set_measure_render_time]. Otherwise, this method returns [code]0.0[/code].
			</description>
		</method>
		<method name="viewport_get_measured_render_time_gpu" qualifiers="const">
			<return type="float" />
			<param index="0" name="viewport" type="RID" />
			<description>
				Returns the GPU time taken to render the last frame in milliseconds. To get a complete readout of GPU time spent to render the scene, sum the render times of all viewports that are drawn every frame. Unlike [method Engine.get_frames_per_second], this method accurately reflects GPU utilization even if framerate is capped via V-Sync or [member Engine.max_fps]. See also [method viewport_get_measured_render_time_cpu].
				[b]Note:[/b] Requires measurements to be enabled on the specified [param viewport] using [method viewport_set_measure_render_time]. Otherwise, this method returns [code]0.0[/code].
				[b]Note:[/b] When GPU utilization is low enough during a certain period of time, GPUs will decrease their power state (which in turn decreases core and memory clock speeds). This can cause the reported GPU time to increase if GPU utilization is kept low enough by a framerate cap (compared to what it would be at the GPU's highest power state). Keep this in mind when benchmarking using [method viewport_get_measured_render_time_gpu]. This behavior can be overridden in the graphics driver settings at the cost of higher power usage.
			</description>
		</method>
		<method


<?xml version="1.0" encoding="UTF-8" ?>
<class name="RichTextLabel" inherits="Control" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A control for displaying text that can contain different font styles, images, and basic formatting.
	</brief_description>
	<description>
		A control for displaying text that can contain custom fonts, images, and basic formatting. [RichTextLabel] manages these as an internal tag stack. It also adapts itself to given width/heights.
		[b]Note:[/b] Assignments to [member text] clear the tag stack and reconstruct it from the property's contents. Any edits made to [member text] will erase previous edits made from other manual sources such as [method append_text] and the [code]push_*[/code] / [method pop] methods.
		[b]Note:[/b] RichTextLabel doesn't support entangled BBCode tags. For example, instead of using [code skip-lint][b]bold[i]bold italic[/b]italic[/i][/code], use [code skip-lint][b]bold[i]bold italic[/i][/b][i]italic[/i][/code].
		[b]Note:[/b] [code]push_*/pop_*[/code] functions won't affect BBCode.
		[b]Note:[/b] Unlike [Label], [RichTextLabel] doesn't have a [i]property[/i] to horizontally align text to the center. Instead, enable [member bbcode_enabled] and surround the text in a [code skip-lint][center][/code] tag as follows: [code skip-lint][center]Example[/center][/code]. There is currently no built-in way to vertically align text either, but this can be emulated by relying on anchors/containers and the [member fit_content] property.
	</description>
	<tutorials>
		<link title="BBCode in RichTextLabel">$DOCS_URL/tutorials/ui/bbcode_in_richtextlabel.html</link>
		<link title="Rich Text Label with BBCode Demo">https://godotengine.org/asset-library/asset/2774</link>
		<link title="Operating System Testing Demo">https://godotengine.org/asset-library/asset/2789</link>
	</tutorials>


<method name="draw_style_box">
			<return type="void" />
			<param index="0" name="style_box" type="StyleBox" />
			<param index="1" name="rect" type="Rect2" />
			<description>
				Draws a styled rectangle.
			</description>
		</method>
		<method name="draw_texture">
			<return type="void" />
			<param index="0" name="texture" type="Texture2D" />
			<param index="1" name="position" type="Vector2" />
			<param index="2" name="modulate" type="Color" default="Color(1, 1, 1, 1)" />
			<description>
				Draws a texture at a given position.
			</description>
		</method>
		<method name="draw_texture_rect">
			<return type="void" />
			<param index="0" name="texture" type="Texture2D" />
			<param index="1" name="rect" type="Rect2" />
			<param index="2" name="tile" type="bool" />
			<param index="3" name="modulate" type="Color" default="Color(1, 1, 1, 1)" />
			<param index="4" name="transpose" type="bool" default="false" />
			<description>
				Draws a textured rectangle at a given position, optionally modulated by a color. If [param transpose] is [code]true[/code], the texture will have its X and Y coordinates swapped. See also [method draw_rect] and [method draw_texture_rect_region].
			</description>
		</method>
		<method name="draw_texture_rect_region">
			<return type="void" />
			<param index="0" name="texture" type="Texture2D" />
			<param index="1" name="rect" type="Rect2" />
			<param index="2" name="src_rect" type="Rect2" />
			<param index="3" name="modulate" type="Color" default="Color(1, 1, 1, 1)" />
			<param index="4" name="transpose" type="bool" default="false" />
			<param index="5" name="clip_uv" type="bool" default="true" />
			<description>
				Draws a textured rectangle from a texture's region (specified by [param src_rect]) at a given position, optionally modulated by a color. If [param transpose] is [code]true[/code], the texture will have its X and Y coordinates swapped. See also [method draw_texture_rect].
			</description>
		</method>
		<method name="force_update_transform">
			<return type="void" />
			<description>
				Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations.
			</description>
		</method>
		<method name="get_canvas" qualifiers="const">
			<return type="RID" />
			<description>
				Returns the [RID] of the [World2D] canvas where this item is in.
			</description>
		</method>
		<method name="get_canvas_item" qualifiers="const">
			<return type="RID" />
			<description>
				Returns the canvas item RID used by [RenderingServer] for this item.
			</description>
		</method>
		<method name="get_canvas_layer_node" qualifiers="const">
			<return type="CanvasLayer" />
			<description>
				Returns the [CanvasLayer] that contains this node, or [code]null[/code] if the node is not in any [CanvasLayer].
			</description>
		</method>
		<method name="get_canvas_transform" qualifiers="const">
			<return type="Transform2D" />
			<description>
				Returns the transform from the coordinate system of the canvas, this item is in, to the [Viewport]s coordinate system.
			</description>
		</method>
		<method name="get_global_mouse_position" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the mouse's position in the [CanvasLayer] that this [CanvasItem] is in using the coordinate system of the [CanvasLayer].
				[b]Note:[/b] For screen-space coordinates (e.g. when using a non-embedded [Popup]), you can use [method DisplayServer.mouse_get_position].
			</description>
		</method>
		<method name="get_global_transform" qualifiers="const">
			<return type="Transform2D" />
			<description>
				Returns the global transform matrix of this item, i.e. the combined transform up to the topmost [CanvasItem] node. The topmost item is a [CanvasItem] that either has no parent, has non-[CanvasItem] parent or it has [member top_level] enabled.
			</description>
		</method>
		<method name="get_global_transform_with_canvas" qualifiers="const">
			<return type="Transform2D" />
			<description>
				Returns the transform from the local coordinate system of this [CanvasItem] to the [Viewport]s coordinate system.
			</description>
		</method>
		<method name="get_local_mouse_position" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the mouse's position in this [CanvasItem] using the local coordinate system of this [CanvasItem].
			</description>
		</method>
		<method name="get_screen_transform" qualifiers="const">
			<return type="Transform2D" />
			<description>
				Returns the transform of this [CanvasItem] in global screen coordinates (i.e. taking window position into account). Mostly useful for editor plugins.
				Equals to [method get_global_transform] if the window is embedded (see [member Viewport.gui_embed_subwindows]).
			</description>
		</method>
		<method name="get_transform" qualifiers="const">
			<return type="Transform2D" />
			<description>
				Returns the transform matrix of this item.
			</description>
		</method>
		<method name="get_viewport_rect" qualifiers="const">
			<return type="Rect2" />
			<description>
				Returns the viewport's boundaries as a [Rect2].
			</description>
		</method>
		<method name="get_viewport_transform" qualifiers="const">
			<return type="Transform2D" />
			<description>
				Returns the transform from the coordinate system of the canvas, this item is in, to the [Viewport]s embedders coordinate system.
			</description>
		</method>
		<method name="get_visibility_layer_bit" qualifiers="const">
			<return type="bool" />
			<param index="0" name="layer" type="int" />
			<description>
				Returns an individual bit on the rendering visibility layer.
			</description>
		</method>
		<method name="get_world_2d" qualifiers="const">
			<return type="World2D" />
			<description>
				Returns the [World2D] where this item is in.
			</description>
		</method>
		<method name="hide">
			<return type="void" />
			<description>
				Hide the [CanvasItem] if it's currently visible. This is equivalent to setting [member visible] to [code]false[/code].
			</description>
		</method>
		<method name="is_local_transform_notification_enabled" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if local transform notifications are communicated to children.
			</description>
		</method>
		<method name="is_transform_notification_enabled" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if global transform notifications are communicated to children.
			</description>
		</method>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="SceneTree" inherits="MainLoop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		Manages the game loop via a hierarchy of nodes.
	</brief_description>
	<description>
		As one of the most important classes, the [SceneTree] manages the hierarchy of nodes in a scene, as well as scenes themselves. Nodes can be added, fetched and removed. The whole scene tree (and thus the current scene) can be paused. Scenes can be loaded, switched and reloaded.
		You can also use the [SceneTree] to organize your nodes into [b]groups[/b]: every node can be added to as many groups as you want to create, e.g. an "enemy" group. You can then iterate these groups or even call methods and set properties on all the nodes belonging to any given group.
		[SceneTree] is the default [MainLoop] implementation used by the engine, and is thus in charge of the game loop.
	</description>
	<tutorials>
		<link title="SceneTree">$DOCS_URL/tutorials/scripting/scene_tree.html</link>
		<link title="Multiple resolutions">$DOCS_URL/tutorials/rendering/multiple_resolutions.html</link>
	</tutorials>


<members>
		<member name="auto_accept_quit" type="bool" setter="set_auto_accept_quit" getter="is_auto_accept_quit" default="true">
			If [code]true[/code], the application automatically accepts quitting requests.
			For mobile platforms, see [member quit_on_go_back].
		</member>
		<member name="current_scene" type="Node" setter="set_current_scene" getter="get_current_scene">
			The root node of the currently loaded main scene, usually as a direct child of [member root]. See also [method change_scene_to_file], [method change_scene_to_packed], and [method reload_current_scene].
			[b]Warning:[/b] Setting this property directly may not work as expected, as it does [i]not[/i] add or remove any nodes from this tree.
		</member>
		<member name="debug_collisions_hint" type="bool" setter="set_debug_collisions_hint" getter="is_debugging_collisions_hint" default="false">
			If [code]true[/code], collision shapes will be visible when running the game from the editor for debugging purposes.
			[b]Note:[/b] This property is not designed to be changed at run-time. Changing the value of [member debug_collisions_hint] while the project is running will not have the desired effect.
		</member>
		<member name="debug_navigation_hint" type="bool" setter="set_debug_navigation_hint" getter="is_debugging_navigation_hint" default="false">
			If [code]true[/code], navigation polygons will be visible when running the game from the editor for debugging purposes.
			[b]Note:[/b] This property is not designed to be changed at run-time. Changing the value of [member debug_navigation_hint] while the project is running will not have the desired effect.
		</member>
		<member name="debug_paths_hint" type="bool" setter="set_debug_paths_hint" getter="is_debugging_paths_hint" default="false">
			If [code]true[/code], curves from [Path2D] and [Path3D] nodes will be visible when running the game from the editor for debugging purposes.
			[b]Note:[/b] This property is not designed to be changed at run-time. Changing the value of [member debug_paths_hint] while the project is running will not have the desired effect.
		</member>
		<member name="edited_scene_root" type="Node" setter="set_edited_scene_root" getter="get_edited_scene_root">
			The root of the scene currently being edited in the editor. This is usually a direct child of [member root].
			[b]Note:[/b] This property does nothing in release builds.
		</member>
		<member name="multiplayer_poll" type="bool" setter="set_multiplayer_poll_enabled" getter="is_multiplayer_poll_enabled" default="true">
			If [code]true[/code] (default value), enables automatic polling of the [MultiplayerAPI] for this SceneTree during [signal process_frame].
			If [code]false[/code], you need to manually call [method MultiplayerAPI.poll] to process network packets and deliver RPCs. This allows running RPCs in a different loop (e.g. physics, thread, specific time step) and for manual [Mutex] protection when accessing the [MultiplayerAPI] from threads.
		</member>
		<member name="paused" type="bool" setter="set_pause" getter="is_paused" default="false">
			If [code]true[/code], the scene tree is considered paused. This causes the following behavior:
			- 2D and 3D physics will be stopped, as well as collision detection and related signals.
			- Depending on each node's [member Node.process_mode], their [method Node._process], [method Node._physics_process] and [method Node._input] callback methods may not called anymore.
		</member>
		<member name="physics_interpolation" type="bool" setter="set_physics_interpolation_enabled" getter="is_physics_interpolation_enabled" default="false">
			If [code]true[/code], the renderer will interpolate the transforms of physics objects between the last two transforms, so that smooth motion is seen even when physics ticks do not coincide with rendered frames.
			The default value of this property is controlled by [member ProjectSettings.physics/common/physics_interpolation].
		</member>
		<member name="quit_on_go_back" type="bool" setter="set_quit_on_go_back" getter="is_quit_on_go_back" default="true">
			If [code]true[/code], the application quits automatically when navigating back (e.g. using the system "Back" button on Android).
			To handle 'Go Back' button when this option is disabled, use [constant DisplayServer.WINDOW_EVENT_GO_BACK_REQUEST].
		</member>
		<member name="root" type="Window" setter="" getter="get_root">
			The tree's root [Window]. This is top-most [Node] of the scene tree, and is always present. An absolute [NodePath] always starts from this node. Children of the root node may include the loaded [member current_scene], as well as any [url=$DOCS_URL/tutorials/scripting/singletons_autoload.html]AutoLoad[/url] configured in the Project Settings.
			[b]Warning:[/b] Do not delete this node. This will result in unstable behavior, followed by a crash.
		</member>
	</members>
	<signals>
		<signal name="node_added">
			<param index="0" name="node" type="Node" />
			<description>
				Emitted when the [param node] enters this tree.
			</description>
		</signal>
		<signal name="node_configuration_warning_changed">
			<param index="0" name="node" type="Node" />
			<description>
				Emitted when the [param node]'s [method Node.update_configuration_warnings] is called. Only emitted in the editor.
			</description>
		</signal>
		<signal name="node_removed">
			<param index="0" name="node" type="Node" />
			<description>
				Emitted when the [param node] exits this tree.
			</description>
		</signal>
		<signal name="node_renamed">
			<param index="0" name="node" type="Node" />
			<description>
				Emitted when the [param node]'s [member Node.name] is changed.
			</description>
		</signal>
		<signal name="physics_frame">
			<description>
				Emitted immediately before [method Node._physics_process] is called on every node in this tree.
			</description>
		</signal>
		<signal name="process_frame">
			<description>
				Emitted immediately before [method Node._process] is called on every node in this tree.
			</description>
		</signal>
		<signal name="tree_changed">
			<description>
				Emitted any time the tree's hierarchy changes (nodes being moved, renamed, etc.).
			</description>
		</signal>
		<signal name="tree_process_mode_changed">
			<description>
				Emitted when the [member Node.process_mode] of any node inside the tree is changed. Only emitted in the editor, to update the visibility of disabled nodes.
			</description>
		</signal>
	</signals>
	<constants>
		<constant name="GROUP_CALL_DEFAULT" value="0" enum="GroupCallFlags">
			Call nodes within a group with no special behavior (default).
		</constant>
		<constant name="GROUP_CALL_REVERSE" value="1" enum="GroupCallFlags">
			Call nodes within a group in reverse tree hierarchy order (all nested children are called before their respective parent nodes).
		</constant>
		<constant name="GROUP_CALL_DEFERRED" value="2" enum="GroupCallFlags">
			Call nodes within a group at the end of the current frame (can be either process or physics frame), similar to [method Object.call_deferred].
		</constant>
		<constant name="GROUP_CALL_UNIQUE" value="4" enum="GroupCallFlags">
			Call nodes within a group only once, even if the call is executed many times in the same frame. Must be combined with [constant GROUP_CALL_DEFERRED] to work.
			[b]Note:[/b] Different arguments are not taken into account. Therefore, when the same call is executed with different arguments, only the first call will be performed.
		</constant>
	</constants>
</class>


<method name="add_index">
			<return type="void" />
			<param index="0" name="index" type="int" />
			<description>
				Adds a vertex to index array if you are using indexed vertices. Does not need to be called before adding vertices.
			</description>
		</method>
		<method name="add_triangle_fan">
			<return type="void" />
			<param index="0" name="vertices" type="PackedVector3Array" />
			<param index="1" name="uvs" type="PackedVector2Array" default="PackedVector2Array()" />
			<param index="2" name="colors" type="PackedColorArray" default="PackedColorArray()" />
			<param index="3" name="uv2s" type="PackedVector2Array" default="PackedVector2Array()" />
			<param index="4" name="normals" type="PackedVector3Array" default="PackedVector3Array()" />
			<param index="5" name="tangents" type="Plane[]" default="[]" />
			<description>
				Inserts a triangle fan made of array data into [Mesh] being constructed.
				Requires the primitive type be set to [constant Mesh.PRIMITIVE_TRIANGLES].
			</description>
		</method>
		<method name="add_vertex">
			<return type="void" />
			<param index="0" name="vertex" type="Vector3" />
			<description>
				Specifies the position of current vertex. Should be called after specifying other vertex properties (e.g. Color, UV).
			</description>
		</method>
		<method name="append_from">
			<return type="void" />
			<param index="0" name="existing" type="Mesh" />
			<param index="1" name="surface" type="int" />
			<param index="2" name="transform" type="Transform3D" />
			<description>
				Append vertices from a given [Mesh] surface onto the current vertex array with specified [Transform3D].
			</description>
		</method>
		<method name="begin">
			<return type="void" />
			<param index="0" name="primitive" type="int" enum="Mesh.PrimitiveType" />
			<description>
				Called before adding any vertices. Takes the primitive type as an argument (e.g. [constant Mesh.PRIMITIVE_TRIANGLES]).
			</description>
		</method>
		<method name="clear">
			<return type="void" />
			<description>
				Clear all information passed into the surface tool so far.
			</description>
		</method>
		<method name="commit">
			<return type="ArrayMesh" />
			<param index="0" name="existing" type="ArrayMesh" default="null" />
			<param index="1" name="flags" type="int" default="0" />
			<description>
				Returns a constructed [ArrayMesh] from current information passed in. If an existing [ArrayMesh] is passed in as an argument, will add an extra surface to the existing [ArrayMesh].
				[b]FIXME:[/b] Document possible values for [param flags], it changed in 4.0. Likely some combinations of [enum Mesh.ArrayFormat].
			</description>
		</method>
		<method name="commit_to_arrays">
			<return type="Array" />
			<description>
				Commits the data to the same format used by [method ArrayMesh.add_surface_from_arrays], [method ImporterMesh.add_surface], and [method create_from_arrays]. This way you can further process the mesh data using the [ArrayMesh] or [ImporterMesh] APIs.
			</description>
		</method>
		<method name="create_from">
			<return type="void" />
			<param index="0" name="existing" type="Mesh" />
			<param index="1" name="surface" type="int" />
			<description>
				Creates a vertex array from an existing [Mesh].
			</description>
		</method>
		<method name="create_from_arrays">
			<return type="void" />
			<param index="0" name="arrays" type="Array" />
			<param index="1" name="primitive_type" type="int" enum="Mesh.PrimitiveType" default="3" />
			<description>
				Creates this SurfaceTool from existing vertex arrays such as returned by [method commit_to_arrays], [method Mesh.surface_get_arrays], [method Mesh.surface_get_blend_shape_arrays], [method ImporterMesh.get_surface_arrays], and [method ImporterMesh.get_surface_blend_shape_arrays]. [param primitive_type] controls the type of mesh data, defaulting to [constant Mesh.PRIMITIVE_TRIANGLES].
			</description>
		</method>
		<method name="create_from_blend_shape">
			<return type="void" />
			<param index="0" name="existing" type="Mesh" />
			<param index="1" name="surface" type="int" />
			<param index="2" name="blend_shape" type="String" />
			<description>
				Creates a vertex array from the specified blend shape of an existing [Mesh]. This can be used to extract a specific pose from a blend shape.
			</description>
		</method>
		<method name="deindex">
			<return type="void" />
			<description>
				Removes the index array by expanding the vertex array.
			</description>
		</method>
		<method name="generate_lod" deprecated="This method is unused internally, as it does not preserve normals or UVs. Consider using [method ImporterMesh.generate_lods] instead.">
			<return type="PackedInt32Array" />
			<param index="0" name="nd_threshold" type="float" />
			<param index="1" name="target_index_count" type="int" default="3" />
			<description>
				Generates an LOD for a given [param nd_threshold] in linear units (square root of quadric error metric), using at most [param target_index_count] indices.
			</description>
		</method>
		<method name="generate_normals">
			<return type="void" />
			<param index="0" name="flip" type="bool" default="false" />
			<description>
				Generates normals from vertices so you do not have to do it manually. If [param flip] is [code]true[/code], the resulting normals will be inverted. [method generate_normals] should be called [i]after[/i] generating geometry and [i]before[/i] committing the mesh using [method commit] or [method commit_to_arrays]. For correct display of normal-mapped surfaces, you will also have to generate tangents using [method generate_tangents].
				[b]Note:[/b] [method generate_normals] only works if the primitive type to be set to [constant Mesh.PRIMITIVE_TRIANGLES].
				[b]Note:[/b] [method generate_normals] takes smooth groups into account. To generate smooth normals, set the smooth group to a value greater than or equal to [code]0[/code] using [method set_smooth_group] or leave the smooth group at the default of [code]0[/code]. To generate flat normals, set the smooth group to [code]-1[/code] using [method set_smooth_group] prior to adding vertices.
			</description>
		</method>
		<method name="generate_tangents">
			<return type="void" />
			<description>
				Generates a tangent vector for each vertex. Requires that each vertex have UVs and normals set already (see [method generate_normals]).
			</description>
		</method>
		<method name="get_aabb" qualifiers="const">
			<return type="AABB" />
			<description>
				Returns the axis-aligned bounding box of the vertex positions.
			</description>
		</method>
		<method name="get_custom_format" qualifiers="const">
			<return type="int" enum="SurfaceTool.CustomFormat" />
			<param index="0" name="channel_index" type="int" />
			<description>
				Returns the format for custom [param channel_index] (currently up to 4). Returns [constant CUSTOM_MAX] if this custom channel is unused.
			</description>
		</method>
		<method name="get_primitive_type" qualifiers="const">
			<return type="int" enum="Mesh.PrimitiveType" />
			<description>
				Returns the type of mesh geometry, such as [constant Mesh.PRIMITIVE_TRIANGLES].
			</description>
		</method>


<method name="get_root_motion_rotation" qualifiers="const">
			<return type="Quaternion" />
			<description>
				Retrieve the motion delta of rotation with the [member root_motion_track] as a [Quaternion] that can be used elsewhere.
				If [member root_motion_track] is not a path to a track of type [constant Animation.TYPE_ROTATION_3D], returns [code]Quaternion(0, 0, 0, 1)[/code].
				See also [member root_motion_track] and [RootMotionView].
				The most basic example is applying rotation to [CharacterBody3D]:
				[codeblocks]
				[gdscript]
				func _process(delta):
				    if Input.is_action_just_pressed("animate"):
				        state_machine.travel("Animate")
				    set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
				[/gdscript]
				[/codeblocks]
			</description>
		</method>
		<method name="get_root_motion_rotation_accumulator" qualifiers="const">
			<return type="Quaternion" />
			<description>
				Retrieve the blended value of the rotation tracks with the [member root_motion_track] as a [Quaternion] that can be used elsewhere.
				This is necessary to apply the root motion position correctly, taking rotation into account. See also [method get_root_motion_position].
				Also, this is useful in cases where you want to respect the initial key values of the animation.
				For example, if an animation with only one key [code]Quaternion(0, 0, 0, 1)[/code] is played in the previous frame and then an animation with only one key [code]Quaternion(0, 0.707, 0, 0.707)[/code] is played in the next frame, the difference can be calculated as follows:
				[codeblocks]
				[gdscript]
				var prev_root_motion_rotation_accumulator: Quaternion

				func _process(delta):
				    if Input.is_action_just_pressed("animate"):
				        state_machine.travel("Animate")
				    var current_root_motion_rotation_accumulator: Quaternion = animation_tree.get_root_motion_rotation_accumulator()
				    var difference: Quaternion = prev_root_motion_rotation_accumulator.inverse() * current_root_motion_rotation_accumulator
				    prev_root_motion_rotation_accumulator = current_root_motion_rotation_accumulator
				    transform.basis *=  Basis(difference)
				[/gdscript]
				[/codeblocks]
				However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
			</description>
		</method>
		<method name="get_root_motion_scale" qualifiers="const">
			<return type="Vector3" />
			<description>
				Retrieve the motion delta of scale with the [member root_motion_track] as a [Vector3] that can be used elsewhere.
				If [member root_motion_track] is not a path to a track of type [constant Animation.TYPE_SCALE_3D], returns [code]Vector3(0, 0, 0)[/code].
				See also [member root_motion_track] and [RootMotionView].
				The most basic example is applying scale to [CharacterBody3D]:
				[codeblocks]
				[gdscript]
				var current_scale: Vector3 = Vector3(1, 1, 1)
				var scale_accum: Vector3 = Vector3(1, 1, 1)

				func _process(delta):
				    if Input.is_action_just_pressed("animate"):
				        current_scale = get_scale()
				        scale_accum = Vector3(1, 1, 1)
				        state_machine.travel("Animate")
				    scale_accum += animation_tree.get_root_motion_scale()
				    set_scale(current_scale * scale_accum)
				[/gdscript]
				[/codeblocks]
			</description>
		</method>
		<method name="get_root_motion_scale_accumulator" qualifiers="const">
			<return type="Vector3" />
			<description>
				Retrieve the blended value of the scale tracks with the [member root_motion_track] as a [Vector3] that can be used elsewhere.
				For example, if an animation with only one key [code]Vector3(1, 1, 1)[/code] is played in the previous frame and then an animation with only one key [code]Vector3(2, 2, 2)[/code] is played in the next frame, the difference can be calculated as follows:
				[codeblocks]
				[gdscript]
				var prev_root_motion_scale_accumulator: Vector3

				func _process(delta):
				    if Input.is_action_just_pressed("animate"):
				        state_machine.travel("Animate")
				    var current_root_motion_scale_accumulator: Vector3 = animation_tree.get_root_motion_scale_accumulator()
				    var difference: Vector3 = current_root_motion_scale_accumulator - prev_root_motion_scale_accumulator
				    prev_root_motion_scale_accumulator = current_root_motion_scale_accumulator
				    transform.basis = transform.basis.scaled(difference)
				[/gdscript]
				[/codeblocks]
				However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
			</description>
		</method>
		<method name="has_animation" qualifiers="const">
			<return type="bool" />
			<param index="0" name="name" type="StringName" />
			<description>
				Returns [code]true[/code] if the [AnimationMixer] stores an [Animation] with key [param name].
			</description>
		</method>
		<method name="has_animation_library" qualifiers="const">
			<return type="bool" />
			<param index="0" name="name" type="StringName" />
			<description>
				Returns [code]true[/code] if the [AnimationMixer] stores an [AnimationLibrary] with key [param name].
			</description>
		</method>
		<method name="remove_animation_library">
			<return type="void" />
			<param index="0" name="name" type="StringName" />
			<description>
				Removes the [AnimationLibrary] associated with the key [param name].
			</description>
		</method>
		<method name="rename_animation_library">
			<return type="void" />
			<param index="0" name="name" type="StringName" />
			<param index="1" name="newname" type="StringName" />
			<description>
				Moves the [AnimationLibrary] associated with the key [param name] to the key [param newname].
			</description>
		</method>
	</methods>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="ImmediateMesh" inherits="Mesh" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		Mesh optimized for creating geometry manually.
	</brief_description>
	<description>
		A mesh type optimized for creating geometry manually, similar to OpenGL 1.x immediate mode.
		Here's a sample on how to generate a triangular face:
		[codeblocks]
		[gdscript]
		var mesh = ImmediateMesh.new()
		mesh.surface_begin(Mesh.PRIMITIVE_TRIANGLES)
		mesh.surface_add_vertex(Vector3.LEFT)
		mesh.surface_add_vertex(Vector3.FORWARD)
		mesh.surface_add_vertex(Vector3.ZERO)
		mesh.surface_end()
		[/gdscript]
		[csharp]
		var mesh = new ImmediateMesh();
		mesh.SurfaceBegin(Mesh.PrimitiveType.Triangles);
		mesh.SurfaceAddVertex(Vector3.Left);
		mesh.SurfaceAddVertex(Vector3.Forward);
		mesh.SurfaceAddVertex(Vector3.Zero);
		mesh.SurfaceEnd();
		[/csharp]
		[/codeblocks]
		[b]Note:[/b] Generating complex geometries with [ImmediateMesh] is highly inefficient. Instead, it is designed to generate simple geometry that changes often.
	</description>
	<tutorials>
		<link title="Using ImmediateMesh">$DOCS_URL/tutorials/3d/procedural_geometry/immediatemesh.html</link>
	</tutorials>
	<methods>
		<method name="clear_surfaces">
			<return type="void" />
			<description>
				Clear all surfaces.
			</description>
		</method>
		<method name="surface_add_vertex">
			<return type="void" />
			<param index="0" name="vertex" type="Vector3" />
			<description>
				Add a 3D vertex using the current attributes previously set.
			</description>
		</method>
		<method name="surface_add_vertex_2d">
			<return type="void" />
			<param index="0" name="vertex" type="Vector2" />
			<description>
				Add a 2D vertex using the current attributes previously set.
			</description>
		</method>
		<method name="surface_begin">
			<return type="void" />
			<param index="0" name="primitive" type="int" enum="Mesh.PrimitiveType" />
			<param index="1" name="material" type="Material" default="null" />
			<description>
				Begin a new surface.
			</description>
		</method>
		<method name="surface_end">
			<return type="void" />
			<description>
				End and commit current surface. Note that surface being created will not be visible until this function is called.
			</description>
		</method>
		<method name="surface_set_color">
			<return type="void" />
			<param index="0" name="color" type="Color" />
			<description>
				Set the color attribute that will be pushed with the next vertex.
			</description>
		</method>
		<method name="surface_set_normal">
			<return type="void" />
			<param index="0" name="normal" type="Vector3" />
			<description>
				Set the normal attribute that will be pushed with the next vertex.
			</description>
		</method>
		<method name="surface_set_tangent">
			<return type="void" />
			<param index="0" name="tangent" type="Plane" />
			<description>
				Set the tangent attribute that will be pushed with the next vertex.
			</description>
		</method>
		<method name="surface_set_uv">
			<return type="void" />
			<param index="0" name="uv" type="Vector2" />
			<description>
				Set the UV attribute that will be pushed with the next vertex.
			</description>
		</method>
		<method name="surface_set_uv2">
			<return type="void" />
			<param index="0" name="uv2" type="Vector2" />
			<description>
				Set the UV2 attribute that will be pushed with the next vertex.
			</description>
		</method>
	</methods>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="Quaternion" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A unit quaternion used for representing 3D rotations.
	</brief_description>
	<description>
		The [Quaternion] built-in [Variant] type is a 4D data structure that represents rotation in the form of a [url=https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation]Hamilton convention quaternion[/url]. Compared to the [Basis] type which can store both rotation and scale, quaternions can [i]only[/i] store rotation.
		A [Quaternion] is composed by 4 floating-point components: [member w], [member x], [member y], and [member z]. These components are very compact in memory, and because of this some operations are more efficient and less likely to cause floating-point errors. Methods such as [method get_angle], [method get_axis], and [method slerp] are faster than their [Basis] counterparts.
		For a great introduction to quaternions, see [url=https://www.youtube.com/watch?v=d4EgbgTm0Bg]this video by 3Blue1Brown[/url]. You do not need to know the math behind quaternions, as Godot provides several helper methods that handle it for you. These include [method slerp] and [method spherical_cubic_interpolate], as well as the [code]*[/code] operator.
		[b]Note:[/b] Quaternions must be normalized before being used for rotation (see [method normalized]).
		[b]Note:[/b] Similarly to [Vector2] and [Vector3], the components of a quaternion use 32-bit precision by default, unlike [float] which is always 64-bit. If double precision is needed, compile the engine with the option [code]precision=double[/code].
	</description>
	<tutorials>
		<link title="3Blue1Brown's video on Quaternions">https://www.youtube.com/watch?v=d4EgbgTm0Bg</link>
		<link title="Online Quaternion Visualization">https://quaternions.online/</link>
		<link title="Using 3D transforms">$DOCS_URL/tutorials/3d/using_transforms.html#interpolating-with-quaternions</link>
		<link title="Third Person Shooter (TPS) Demo">https://godotengine.org/asset-library/asset/2710</link>
		<link title="Advanced Quaternion Visualization">https://iwatake2222.github.io/rotation_master/rotation_master.html</link>
	</tutorials>
	<constructors>
		<constructor name="Quaternion">
			<return type="Quaternion" />
			<description>
				Constructs a [Quaternion] identical to the [constant IDENTITY].
			</description>
		</constructor>
		<constructor name="Quaternion">
			<return type="Quaternion" />
			<param index="0" name="from" type="Quaternion" />
			<description>
				Constructs a [Quaternion] as a copy of the given [Quaternion].
			</description>
		</constructor>
		<constructor name="Quaternion">
			<return type="Quaternion" />
			<param index="0" name="arc_from" type="Vector3" />
			<param index="1" name="arc_to" type="Vector3" />
			<description>
				Constructs a [Quaternion] representing the shortest arc between [param arc_from] and [param arc_to]. These can be imagined as two points intersecting a sphere's surface, with a radius of [code]1.0[/code].
			</description>
		</constructor>
		<constructor name="Quaternion">
			<return type="Quaternion" />
			<param index="0" name="axis" type="Vector3" />
			<param index="1" name="angle" type="float" />
			<description>
				Constructs a [Quaternion] representing rotation around the [param axis] by the given [param angle], in radians. The axis must be a normalized vector.
			</description>
		</constructor>
		<constructor name="Quaternion">
			<return type="Quaternion" />
			<param index="0" name="from" type="Basis" />
			<description>
				Constructs a [Quaternion] from the given rotation [Basis].
				This constructor is faster than [method Basis.get_rotation_quaternion], but the given basis must be [i]orthonormalized[/i] (see [method Basis.orthonormalized]). Otherwise, the constructor fails and returns [constant IDENTITY].
			</description>
		</constructor>
		<constructor name="Quaternion">
			<return type="Quaternion" />
			<param index="0" name="x" type="float" />
			<param index="1" name="y" type="float" />
			<param index="2" name="z" type="float" />
			<param index="3" name="w" type="float" />
			<description>
				Constructs a [Quaternion] defined by the given values.
				[b]Note:[/b] Only normalized quaternions represent rotation; if these values are not normalized, the new [Quaternion] will not be a valid rotation.
			</description>
		</constructor>
	</constructors>


<methods>
		<method name="angle_to" qualifiers="const">
			<return type="float" />
			<param index="0" name="to" type="Quaternion" />
			<description>
				Returns the angle between this quaternion and [param to]. This is the magnitude of the angle you would need to rotate by to get from one to the other.
				[b]Note:[/b] The magnitude of the floating-point error for this method is abnormally high, so methods such as [code]is_zero_approx[/code] will not work reliably.
			</description>
		</method>
		<method name="dot" qualifiers="const">
			<return type="float" />
			<param index="0" name="with" type="Quaternion" />
			<description>
				Returns the dot product between this quaternion and [param with].
				This is equivalent to [code](quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w)[/code].
			</description>
		</method>
		<method name="exp" qualifiers="const">
			<return type="Quaternion" />
			<description>
				Returns the exponential of this quaternion. The rotation axis of the result is the normalized rotation axis of this quaternion, the angle of the result is the length of the vector part of this quaternion.
			</description>
		</method>
		<method name="from_euler" qualifiers="static">
			<return type="Quaternion" />
			<param index="0" name="euler" type="Vector3" />
			<description>
				Constructs a new [Quaternion] from the given [Vector3] of [url=https://en.wikipedia.org/wiki/Euler_angles]Euler angles[/url], in radians. This method always uses the YXZ convention ([constant EULER_ORDER_YXZ]).
			</description>
		</method>
		<method name="get_angle" qualifiers="const">
			<return type="float" />
			<description>
				Returns the angle of the rotation represented by this quaternion.
				[b]Note:[/b] The quaternion must be normalized.
			</description>
		</method>
		<method name="get_axis" qualifiers="const">
			<return type="Vector3" />
			<description>
				Returns the rotation axis of the rotation represented by this quaternion.
			</description>
		</method>
		<method name="get_euler" qualifiers="const">
			<return type="Vector3" />
			<param index="0" name="order" type="int" default="2" />
			<description>
				Returns this quaternion's rotation as a [Vector3] of [url=https://en.wikipedia.org/wiki/Euler_angles]Euler angles[/url], in radians.
				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.
			</description>
		</method>
		<method name="inverse" qualifiers="const">
			<return type="Quaternion" />
			<description>
				Returns the inverse version of this quaternion, inverting the sign of every component except [member w].
			</description>
		</method>
		<method name="is_equal_approx" qualifiers="const">
			<return type="bool" />
			<param index="0" name="to" type="Quaternion" />
			<description>
				Returns [code]true[/code] if this quaternion and [param to] are approximately equal, by running [method @GlobalScope.is_equal_approx] on each component.
			</description>
		</method>
		<method name="is_finite" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if this quaternion is finite, by calling [method @GlobalScope.is_finite] on each component.
			</description>
		</method>
		<method name="is_normalized" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if this quaternion is normalized. See also [method normalized].
			</description>
		</method>
		<method name="length" qualifiers="const" keywords="size">
			<return type="float" />
			<description>
				Returns this quaternion's length, also called magnitude.
			</description>
		</method>
		<method name="length_squared" qualifiers="const">
			<return type="float" />
			<description>
				Returns this quaternion's length, squared.
				[b]Note:[/b] This method is faster than [method length], so prefer it if you only need to compare quaternion lengths.
			</description>
		</method>
		<method name="log" qualifiers="const">
			<return type="Quaternion" />
			<description>
				Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part ([member x], [member y], and [member z]). The returned quaternion's real part ([member w]) is always [code]0.0[/code].
			</description>
		</method>
		<method name="normalized" qualifiers="const">
			<return type="Quaternion" />
			<description>
				Returns a copy of this quaternion, normalized so that its length is [code]1.0[/code]. See also [method is_normalized].
			</description>
		</method>
		<method name="slerp" qualifiers="const" keywords="interpolate">
			<return type="Quaternion" />
			<param index="0" name="to" type="Quaternion" />
			<param index="1" name="weight" type="float" />
			<description>
				Performs a spherical-linear interpolation with the [param to] quaternion, given a [param weight] and returns the result. Both this quaternion and [param to] must be normalized.
			</description>
		</method>
		<method name="slerpni" qualifiers="const">
			<return type="Quaternion" />
			<param index="0" name="to" type="Quaternion" />
			<param index="1" name="weight" type="float" />
			<description>
				Performs a spherical-linear interpolation with the [param to] quaternion, given a [param weight] and returns the result. Unlike [method slerp], this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and [param to] must be normalized.
			</description>
		</method>
		<method name="spherical_cubic_interpolate" qualifiers="const">
			<return type="Quaternion" />
			<param index="0" name="b" type="Quaternion" />
			<param index="1" name="pre_a" type="Quaternion" />
			<param index="2" name="post_b" type="Quaternion" />
			<param index="3" name="weight" type="float" />
			<description>
				Performs a spherical cubic interpolation between quaternions [param pre_a], this vector, [param b], and [param post_b], by the given amount [param weight].
			</description>
		</method>
		<method name="spherical_cubic_interpolate_in_time" qualifiers="const">
			<return type="Quaternion" />
			<param index="0" name="b" type="Quaternion" />
			<param index="1" name="pre_a" type="Quaternion" />
			<param index="2" name="post_b" type="Quaternion" />
			<param index="3" name="weight" type="float" />
			<param index="4" name="b_t" type="float" />
			<param index="5" name="pre_a_t" type="float" />
			<param index="6" name="post_b_t" type="float" />
			<description>
				Performs a spherical cubic interpolation between quaternions [param pre_a], this vector, [param b], and [param post_b], by the given amount [param weight].
				It can perform smoother interpolation than [method spherical_cubic_interpolate] by the time values.
			</description>
		</method>
	</methods>


<members>
		<member name="w" type="float" setter="" getter="" default="1.0">
			W component of the quaternion. This is the "real" part.
			[b]Note:[/b] Quaternion components should usually not be manipulated directly.
		</member>
		<member name="x" type="float" setter="" getter="" default="0.0">
			X component of the quaternion. This is the value along the "imaginary" [code]i[/code] axis.
			[b]Note:[/b] Quaternion components should usually not be manipulated directly.
		</member>
		<member name="y" type="float" setter="" getter="" default="0.0">
			Y component of the quaternion. This is the value along the "imaginary" [code]j[/code] axis.
			[b]Note:[/b] Quaternion components should usually not be manipulated directly.
		</member>
		<member name="z" type="float" setter="" getter="" default="0.0">
			Z component of the quaternion. This is the value along the "imaginary" [code]k[/code] axis.
			[b]Note:[/b] Quaternion components should usually not be manipulated directly.
		</member>
	</members>
	<constants>
		<constant name="IDENTITY" value="Quaternion(0, 0, 0, 1)">
			The identity quaternion, representing no rotation. This has the same rotation as [constant Basis.IDENTITY].
			If a [Vector3] is rotated (multiplied) by this quaternion, it does not change.
		</constant>
	</constants>
	<operators>
		<operator name="operator !=">
			<return type="bool" />
			<param index="0" name="right" type="Quaternion" />
			<description>
				Returns [code]true[/code] if the components of both quaternions are not exactly equal.
				[b]Note:[/b] Due to floating-point precision errors, consider using [method is_equal_approx] instead, which is more reliable.
			</description>
		</operator>
		<operator name="operator *">
			<return type="Quaternion" />
			<param index="0" name="right" type="Quaternion" />
			<description>
				Composes (multiplies) two quaternions. This rotates the [param right] quaternion (the child) by this quaternion (the parent).
			</description>
		</operator>
		<operator name="operator *">
			<return type="Vector3" />
			<param index="0" name="right" type="Vector3" />
			<description>
				Rotates (multiplies) the [param right] vector by this quaternion, returning a [Vector3].
			</description>
		</operator>
		<operator name="operator *">
			<return type="Quaternion" />
			<param index="0" name="right" type="float" />
			<description>
				Multiplies each component of the [Quaternion] by the right [float] value.
				This operation is not meaningful on its own, but it can be used as a part of a larger expression.
			</description>
		</operator>
		<operator name="operator *">
			<return type="Quaternion" />
			<param index="0" name="right" type="int" />
			<description>
				Multiplies each component of the [Quaternion] by the right [int] value.
				This operation is not meaningful on its own, but it can be used as a part of a larger expression.
			</description>
		</operator>
		<operator name="operator +">
			<return type="Quaternion" />
			<param index="0" name="right" type="Quaternion" />
			<description>
				Adds each component of the left [Quaternion] to the right [Quaternion].
				This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations.
			</description>
		</operator>
		<operator name="operator -">
			<return type="Quaternion" />
			<param index="0" name="right" type="Quaternion" />
			<description>
				Subtracts each component of the left [Quaternion] by the right [Quaternion].
				This operation is not meaningful on its own, but it can be used as a part of a larger expression.
			</description>
		</operator>
		<operator name="operator /">
			<return type="Quaternion" />
			<param index="0" name="right" type="float" />
			<description>
				Divides each component of the [Quaternion] by the right [float] value.
				This operation is not meaningful on its own, but it can be used as a part of a larger expression.
			</description>
		</operator>
		<operator name="operator /">
			<return type="Quaternion" />
			<param index="0" name="right" type="int" />
			<description>
				Divides each component of the [Quaternion] by the right [int] value.
				This operation is not meaningful on its own, but it can be used as a part of a larger expression.
			</description>
		</operator>
		<operator name="operator ==">
			<return type="bool" />
			<param index="0" name="right" type="Quaternion" />
			<description>
				Returns [code]true[/code] if the components of both quaternions are exactly equal.
				[b]Note:[/b] Due to floating-point precision errors, consider using [method is_equal_approx] instead, which is more reliable.
			</description>
		</operator>
		<operator name="operator []">
			<return type="float" />
			<param index="0" name="index" type="int" />
			<description>
				Accesses each component of this quaternion by their index.
				Index [code]0[/code] is the same as [member x], index [code]1[/code] is the same as [member y], index [code]2[/code] is the same as [member z], and index [code]3[/code] is the same as [member w].
			</description>
		</operator>
		<operator name="operator unary+">
			<return type="Quaternion" />
			<description>
				Returns the same value as if the [code]+[/code] was not there. Unary [code]+[/code] does nothing, but sometimes it can make your code more readable.
			</description>
		</operator>
		<operator name="operator unary-">
			<return type="Quaternion" />
			<description>
				Returns the negative value of the [Quaternion]. This is the same as multiplying all components by [code]-1[/code]. This operation results in a quaternion that represents the same rotation.
			</description>
		</operator>
	</operators>
</class>


<?xml version="1.0" encoding="UTF-8" ?>
<class name="CharacterBody2D" inherits="PhysicsBody2D" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
	<brief_description>
		A 2D physics body specialized for characters moved by script.
	</brief_description>
	<description>
		[CharacterBody2D] is a specialized class for physics bodies that are meant to be user-controlled. They are not affected by physics at all, but they affect other physics bodies in their path. They are mainly used to provide high-level API to move objects with wall and slope detection ([method move_and_slide] method) in addition to the general collision detection provided by [method PhysicsBody2D.move_and_collide]. This makes it useful for highly configurable physics bodies that must move in specific ways and collide with the world, as is often the case with user-controlled characters.
		For game objects that don't require complex movement or collision detection, such as moving platforms, [AnimatableBody2D] is simpler to configure.
	</description>
	<tutorials>
		<link title="Kinematic character (2D)">$DOCS_URL/tutorials/physics/kinematic_character_2d.html</link>
		<link title="Using CharacterBody2D">$DOCS_URL/tutorials/physics/using_character_body_2d.html</link>
		<link title="2D Kinematic Character Demo">https://godotengine.org/asset-library/asset/2719</link>
		<link title="2D Platformer Demo">https://godotengine.org/asset-library/asset/2727</link>
	</tutorials>


<methods>
		<method name="apply_floor_snap">
			<return type="void" />
			<description>
				Allows to manually apply a snap to the floor regardless of the body's velocity. This function does nothing when [method is_on_floor] returns [code]true[/code].
			</description>
		</method>
		<method name="get_floor_angle" qualifiers="const">
			<return type="float" />
			<param index="0" name="up_direction" type="Vector2" default="Vector2(0, -1)" />
			<description>
				Returns the floor's collision angle at the last collision point according to [param up_direction], which is [constant Vector2.UP] by default. This value is always positive and only valid after calling [method move_and_slide] and when [method is_on_floor] returns [code]true[/code].
			</description>
		</method>
		<method name="get_floor_normal" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the collision normal of the floor at the last collision point. Only valid after calling [method move_and_slide] and when [method is_on_floor] returns [code]true[/code].
				[b]Warning:[/b] The collision normal is not always the same as the surface normal.
			</description>
		</method>
		<method name="get_last_motion" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the last motion applied to the [CharacterBody2D] during the last call to [method move_and_slide]. The movement can be split into multiple motions when sliding occurs, and this method return the last one, which is useful to retrieve the current direction of the movement.
			</description>
		</method>
		<method name="get_last_slide_collision">
			<return type="KinematicCollision2D" />
			<description>
				Returns a [KinematicCollision2D], which contains information about the latest collision that occurred during the last call to [method move_and_slide].
			</description>
		</method>
		<method name="get_platform_velocity" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the linear velocity of the platform at the last collision point. Only valid after calling [method move_and_slide].
			</description>
		</method>
		<method name="get_position_delta" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the travel (position delta) that occurred during the last call to [method move_and_slide].
			</description>
		</method>
		<method name="get_real_velocity" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the current real velocity since the last call to [method move_and_slide]. For example, when you climb a slope, you will move diagonally even though the velocity is horizontal. This method returns the diagonal movement, as opposed to [member velocity] which returns the requested velocity.
			</description>
		</method>
		<method name="get_slide_collision">
			<return type="KinematicCollision2D" />
			<param index="0" name="slide_idx" type="int" />
			<description>
				Returns a [KinematicCollision2D], which contains information about a collision that occurred during the last call to [method move_and_slide]. Since the body can collide several times in a single call to [method move_and_slide], you must specify the index of the collision in the range 0 to ([method get_slide_collision_count] - 1).
				[b]Example usage:[/b]
				[codeblocks]
				[gdscript]
				for i in get_slide_collision_count():
				    var collision = get_slide_collision(i)
				    print("Collided with: ", collision.get_collider().name)
				[/gdscript]
				[csharp]
				for (int i = 0; i < GetSlideCollisionCount(); i++)
				{
				    KinematicCollision2D collision = GetSlideCollision(i);
				    GD.Print("Collided with: ", (collision.GetCollider() as Node).Name);
				}
				[/csharp]
				[/codeblocks]
			</description>
		</method>
		<method name="get_slide_collision_count" qualifiers="const">
			<return type="int" />
			<description>
				Returns the number of times the body collided and changed direction during the last call to [method move_and_slide].
			</description>
		</method>
		<method name="get_wall_normal" qualifiers="const">
			<return type="Vector2" />
			<description>
				Returns the collision normal of the wall at the last collision point. Only valid after calling [method move_and_slide] and when [method is_on_wall] returns [code]true[/code].
				[b]Warning:[/b] The collision normal is not always the same as the surface normal.
			</description>
		</method>
		<method name="is_on_ceiling" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided with the ceiling on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "ceiling" or not.
			</description>
		</method>
		<method name="is_on_ceiling_only" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided only with the ceiling on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "ceiling" or not.
			</description>
		</method>
		<method name="is_on_floor" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided with the floor on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "floor" or not.
			</description>
		</method>
		<method name="is_on_floor_only" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided only with the floor on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "floor" or not.
			</description>
		</method>
		<method name="is_on_wall" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided with a wall on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "wall" or not.
			</description>
		</method>
		<method name="is_on_wall_only" qualifiers="const">
			<return type="bool" />
			<description>
				Returns [code]true[/code] if the body collided only with a wall on the last call of [method move_and_slide]. Otherwise, returns [code]false[/code]. The [member up_direction] and [member floor_max_angle] are used to determine whether a surface is "wall" or not.
			</description>
		</method>
		<method name="move_and_slide">
			<return type="bool" />
			<description>
				Moves the body based on [member velocity]. If the body collides with another, it will slide along the other body (by default only on floor) rather than stop immediately. If the other body is a [CharacterBody2D] or [RigidBody2D], it will also be affected by the motion of the other body. You can use this to make moving and rotating platforms, or to make nodes push other nodes.
				Modifies [member velocity] if a slide collision occurred. To get the latest collision call [method get_last_slide_collision], for detailed information about collisions that occurred, use [method get_slide_collision].
				When the body touches a moving platform, the platform's velocity is automatically added to the body motion. If a collision occurs due to the platform's motion, it will always be first in the slide collisions.
				The general behavior and available properties change according to the [member motion_mode].
				Returns [code]true[/code] if the body collided, otherwise, returns [code]false[/code].
			</description>
		</method>
	</methods>