PhysicsDirectBodyState2D

public float AngularVelocity { get; set; }

The body's rotational velocity in radians per second.

public Vector2 CenterOfMass { get; }

The body's center of mass position relative to the body's center in the global coordinate system.

public Vector2 CenterOfMassLocal { get; }

The body's center of mass position in the body's local coordinate system.

public uint CollisionLayer { get; set; }

The body's collision layer.

public uint CollisionMask { get; set; }

The body's collision mask.

public float InverseInertia { get; }

The inverse of the inertia of the body.

public float InverseMass { get; }

The inverse of the mass of the body.

public Vector2 LinearVelocity { get; set; }

The body's linear velocity in pixels per second.

public bool Sleeping { get; set; }

If true, this body is currently sleeping (not active).

public float Step { get; }

The timestep (delta) used for the simulation.

public float TotalAngularDamp { get; }

The rate at which the body stops rotating, if there are not any other forces moving it.

public Vector2 TotalGravity { get; }

The total gravity vector being currently applied to this body.

public float TotalLinearDamp { get; }

The rate at which the body stops moving, if there are not any other forces moving it.

public Transform2D Transform { get; set; }

The body's transformation matrix.

public void AddConstantCentralForce(Vector2? force = default);

Adds a constant directional force without affecting rotation that keeps being applied over time until cleared with constant_force = Vector2(0, 0). This is equivalent to using PhysicsDirectBodyState2D.AddConstantForce at the body's center of mass.

public void AddConstantForce(Vector2 force, Vector2? position = default);

Adds a constant positioned force to the body that keeps being applied over time until cleared with constant_force = Vector2(0, 0). position is the offset from the body origin in global coordinates.

public void AddConstantTorque(float torque);

Adds a constant rotational force without affecting position that keeps being applied over time until cleared with constant_torque = 0.

public void ApplyCentralForce(Vector2? force = default);

Applies a directional force without affecting rotation. A force is time dependent and meant to be applied every physics update. This is equivalent to using PhysicsDirectBodyState2D.ApplyForce at the body's center of mass.

public void ApplyCentralImpulse(Vector2 impulse);

Applies a directional impulse without affecting rotation. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise). This is equivalent to using PhysicsDirectBodyState2D.ApplyImpulse at the body's center of mass.

public void ApplyForce(Vector2 force, Vector2? position = default);

Applies a positioned force to the body. A force is time dependent and meant to be applied every physics update. position is the offset from the body origin in global coordinates.

public void ApplyImpulse(Vector2 impulse, Vector2? position = default);

Applies a positioned impulse to the body. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise). position is the offset from the body origin in global coordinates.

public void ApplyTorque(float torque);

Applies a rotational force without affecting position. A force is time dependent and meant to be applied every physics update. Note: PhysicsDirectBodyState2D.InverseInertia is required for this to work. To have PhysicsDirectBodyState2D.InverseInertia, an active CollisionShape2D must be a child of the node, or you can manually set PhysicsDirectBodyState2D.InverseInertia.

public void ApplyTorqueImpulse(float impulse);

Applies a rotational impulse to the body without affecting the position. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise). Note: PhysicsDirectBodyState2D.InverseInertia is required for this to work. To have PhysicsDirectBodyState2D.InverseInertia, an active CollisionShape2D must be a child of the node, or you can manually set PhysicsDirectBodyState2D.InverseInertia.

public Vector2 GetConstantForce();

Returns the body's total constant positional forces applied during each physics update. See PhysicsDirectBodyState2D.AddConstantForce and PhysicsDirectBodyState2D.AddConstantCentralForce.

public float GetConstantTorque();

Returns the body's total constant rotational forces applied during each physics update. See PhysicsDirectBodyState2D.AddConstantTorque.

public Rid GetContactCollider(int contactIdx);

Returns the collider's Rid.

public ulong GetContactColliderId(int contactIdx);

Returns the collider's object id.

public ReckfellObject GetContactColliderObject(int contactIdx);

Returns the collider object. This depends on how it was created (will return a scene node if such was used to create it).

public Vector2 GetContactColliderPosition(int contactIdx);

Returns the position of the contact point on the collider in the global coordinate system.

public int GetContactColliderShape(int contactIdx);

Returns the collider's shape index.

public Vector2 GetContactColliderVelocityAtPosition(int contactIdx);

Returns the velocity vector at the collider's contact point.

public int GetContactCount();

Returns the number of contacts this body has with other bodies. Note: By default, this returns 0 unless bodies are configured to monitor contacts. See RigidBody2D.ContactMonitor.

public Vector2 GetContactImpulse(int contactIdx);

Returns the impulse created by the contact.

public Vector2 GetContactLocalNormal(int contactIdx);

Returns the local normal at the contact point.

public Vector2 GetContactLocalPosition(int contactIdx);

Returns the position of the contact point on the body in the global coordinate system.

public int GetContactLocalShape(int contactIdx);

Returns the local shape index of the collision.

public Vector2 GetContactLocalVelocityAtPosition(int contactIdx);

Returns the velocity vector at the body's contact point.

public PhysicsDirectSpaceState2D GetSpaceState();

Returns the current state of the space, useful for queries.

public Vector2 GetVelocityAtLocalPosition(Vector2 localPosition);

Returns the body's velocity at the given relative position. local_position is the offset from the body origin in global coordinates.

public void IntegrateForces();

Updates the body's linear and angular velocity by applying gravity and damping for the equivalent of one physics tick.

public void SetConstantForce(Vector2 force);

Sets the body's total constant positional forces applied during each physics update. See PhysicsDirectBodyState2D.AddConstantForce and PhysicsDirectBodyState2D.AddConstantCentralForce.

public void SetConstantTorque(float torque);

Sets the body's total constant rotational forces applied during each physics update. See PhysicsDirectBodyState2D.AddConstantTorque.