Entity2D

public Vector2 GlobalPosition { get; set; }

Origin position in the item's canvas, excluding camera and window transforms. Assignment converts the point through the parent CanvasItem inverse transform; when a parent applies, its basis must be invertible.

public float GlobalRotation { get; set; }

Global rotation in radians. See also Entity2D.Rotation.

public float GlobalRotationDegrees { get; set; }

Helper property to access Entity2D.GlobalRotation in degrees instead of radians. See also Entity2D.RotationDegrees.

public Vector2 GlobalScale { get; set; }

Global scale. See also Entity2D.Scale.

public float GlobalSkew { get; set; }

Global skew in radians. See also Entity2D.Skew.

public Transform2D GlobalTransform { get; set; }

Affine transform from item-local coordinates to its canvas, including inherited CanvasItem ancestors. Does not include Camera2D, CanvasLayer or final window presentation; use GetGlobalTransformWithCanvas for the canvas stage.

public Vector2 Position { get; set; }

Origin position in the parent CanvasItem local space. Parent rotation and scale affect the resulting GlobalPosition. With TopLevel the parent CanvasItem transform is not inherited.

public float Rotation { get; set; }

Rotation in radians, relative to the entity's parent. See also Entity2D.GlobalRotation. Note: This property is edited in the inspector in degrees. If you want to use degrees in a script, use Entity2D.RotationDegrees.

public float RotationDegrees { get; set; }

Helper property to access Entity2D.Rotation in degrees instead of radians. See also Entity2D.GlobalRotationDegrees.

public Vector2 Scale { get; set; }

The entity's scale, relative to the entity's parent. Unscaled value: (1, 1). See also Entity2D.GlobalScale. Note: Negative X scales in 2D are not decomposable from the transformation matrix. Due to the way scale is represented with transformation matrices in Reckfell, negative scales on the X axis will be changed to negative scales on the Y axis and a rotation of 180 degrees when decomposed.

public float Skew { get; set; }

If set to a non-zero value, slants the entity in one direction or another. This can be used for pseudo-3D effects. See also Entity2D.GlobalSkew. Note: Skew is performed on the X axis only, and between rotation and scaling. Note: This property is edited in the inspector in degrees. If you want to use degrees in a script, use skew = deg_to_rad(value_in_degrees).

public Transform2D Transform { get; set; }

Item-local affine transform: basis and translation relative to the parent CanvasItem. Hierarchy composition uses parentTransform * childTransform.

public void ApplyScale(Vector2 ratio);

Multiplies the current scale by the ratio vector.

public float GetAngleTo(Vector2 point);

Returns an angle in radians for a world-space point relative to this Entity2D. The implementation takes the angle of ToLocal(point) multiplied componentwise by the entity Scale. Keep the point in world coordinates; the result depends on the current transform. See also Entity2D.LookAt.

public Transform2D GetRelativeTransformToParent(Entity parent);

Composes the transform to the specified ancestor through an Entity2D parent chain; returns identity for the item itself. This is not a conversion between arbitrary siblings and does not include canvas/camera transforms.

public void GlobalTranslate(Vector2 offset);

Adds the offset vector to the entity's global position.

public void LookAt(Vector2 point);

Rotates the entity so that its local +X axis points towards the point, which is expected to use global coordinates. This method is a combination of both Entity2D.Rotate and Entity2D.GetAngleTo. point should not be the same as the entity's position, otherwise the entity always looks to the right.

public void MoveLocalX(float delta, bool scaled = false);

Applies a local translation on the entity's X axis with the amount specified in delta. If scaled is false, normalizes the movement to occur independently of the entity's Entity2D.Scale.

public void MoveLocalY(float delta, bool scaled = false);

Applies a local translation on the entity's Y axis with the amount specified in delta. If scaled is false, normalizes the movement to occur independently of the entity's Entity2D.Scale.

public void Rotate(float radians);

Applies a rotation to the entity, in radians, starting from its current rotation. This is equivalent to rotation += radians.

public Vector2 ToGlobal(Vector2 localPoint);

Converts an item-local point to its canvas coordinates using GlobalTransform. Does not add the camera or window transform. Passing the item's own Position instead of a local point usually applies its offset twice.

public Vector2 ToLocal(Vector2 globalPoint);

Converts a point from the item's canvas to item-local coordinates using the affine inverse of GlobalTransform. This does not convert an OS screen position or a camera-transformed logical viewport point; the basis must be invertible.

public void Translate(Vector2 offset);

Translates the entity by the given offset in local coordinates. This is equivalent to position += offset.