- _bodyEnterTree
void _bodyEnterTree(long arg0)
- _bodyExitTree
void _bodyExitTree(long arg0)
- _directStateChanged
void _directStateChanged(GodotObject arg0)
- _integrateForces
void _integrateForces(PhysicsDirectBodyState state)
Called during physics processing, allowing you to read and safely modify the simulation state for the object. By default it works in addition to the usual physics behavior, but setUseCustomIntegrator allows you to disable the default behavior and do fully custom force integration for a body.
- _reloadPhysicsCharacteristics
void _reloadPhysicsCharacteristics()
- addCentralForce
void addCentralForce(Vector3 force)
Adds a constant directional force without affecting rotation.
This is equivalent to add_force(force, Vector3(0,0,0)).
- addForce
void addForce(Vector3 force, Vector3 position)
Adds a constant force (i.e. acceleration).
- addTorque
void addTorque(Vector3 torque)
Adds a constant rotational force (i.e. a motor) without affecting position.
- applyCentralImpulse
void applyCentralImpulse(Vector3 impulse)
Applies a directional impulse without affecting rotation.
This is equivalent to apply_impulse(Vector3(0,0,0), impulse).
- applyImpulse
void applyImpulse(Vector3 position, Vector3 impulse)
Applies a positioned impulse which will be affected by the body mass and shape. This is the equivalent of hitting a billiard ball with a cue: a force that is applied once, and only once. Both the impulse and the position are in global coordinates, and the position is relative to the object's origin.
- applyTorqueImpulse
void applyTorqueImpulse(Vector3 impulse)
Applies a torque impulse which will be affected by the body mass and shape. This will rotate the body around the passed in vector.
- getAngularDamp
double getAngularDamp()
- getAngularVelocity
Vector3 getAngularVelocity()
- getAxisLock
bool getAxisLock(long axis)
- getBounce
double getBounce()
- getCollidingBodies
Array getCollidingBodies()
Return a list of the bodies colliding with this one. By default, number of max contacts reported is at 0 , see setMaxContactsReported to increase it. Note that the result of this test is not immediate after moving objects. For performance, list of collisions is updated once per frame and before the physics step. Consider using signals instead.
- getFriction
double getFriction()
- getGravityScale
double getGravityScale()
- getLinearDamp
double getLinearDamp()
- getLinearVelocity
Vector3 getLinearVelocity()
- getMass
double getMass()
- getMaxContactsReported
long getMaxContactsReported()
- getMode
RigidBody.Mode getMode()
- getPhysicsMaterialOverride
Ref!PhysicsMaterial getPhysicsMaterialOverride()
- getWeight
double getWeight()
- isAbleToSleep
bool isAbleToSleep()
- isContactMonitorEnabled
bool isContactMonitorEnabled()
- isSleeping
bool isSleeping()
- isUsingContinuousCollisionDetection
bool isUsingContinuousCollisionDetection()
- isUsingCustomIntegrator
bool isUsingCustomIntegrator()
- opAssign
RigidBody opAssign(T n)
Undocumented in source. Be warned that the author may not have intended to support it.
- opEquals
bool opEquals(RigidBody other)
Undocumented in source. Be warned that the author may not have intended to support it.
- opEquals
bool opEquals(typeof(null) n)
Undocumented in source. Be warned that the author may not have intended to support it.
- setAngularDamp
void setAngularDamp(double angular_damp)
- setAngularVelocity
void setAngularVelocity(Vector3 angular_velocity)
- setAxisLock
void setAxisLock(long axis, bool lock)
- setAxisVelocity
void setAxisVelocity(Vector3 axis_velocity)
Sets an axis velocity. The velocity in the given vector axis will be set as the given vector length. This is useful for jumping behavior.
- setBounce
void setBounce(double bounce)
- setCanSleep
void setCanSleep(bool able_to_sleep)
- setContactMonitor
void setContactMonitor(bool enabled)
- setFriction
void setFriction(double friction)
- setGravityScale
void setGravityScale(double gravity_scale)
- setLinearDamp
void setLinearDamp(double linear_damp)
- setLinearVelocity
void setLinearVelocity(Vector3 linear_velocity)
- setMass
void setMass(double mass)
- setMaxContactsReported
void setMaxContactsReported(long amount)
- setMode
void setMode(long mode)
- setPhysicsMaterialOverride
void setPhysicsMaterialOverride(PhysicsMaterial physics_material_override)
- setSleeping
void setSleeping(bool sleeping)
- setUseContinuousCollisionDetection
void setUseContinuousCollisionDetection(bool enable)
- setUseCustomIntegrator
void setUseCustomIntegrator(bool enable)
- setWeight
void setWeight(double weight)
- angularDamp
double angularDamp [@property getter]
double angularDamp [@property setter]
Damps RigidBody's rotational forces.
- angularVelocity
Vector3 angularVelocity [@property getter]
Vector3 angularVelocity [@property setter]
RigidBody's rotational velocity.
- axisLockAngularX
bool axisLockAngularX [@property getter]
bool axisLockAngularX [@property setter]
Lock the body's rotation in the x-axis.
- axisLockAngularY
bool axisLockAngularY [@property getter]
bool axisLockAngularY [@property setter]
Lock the body's rotation in the y-axis.
- axisLockAngularZ
bool axisLockAngularZ [@property getter]
bool axisLockAngularZ [@property setter]
Lock the body's rotation in the z-axis.
- axisLockLinearX
bool axisLockLinearX [@property getter]
bool axisLockLinearX [@property setter]
Lock the body's movement in the x-axis.
- axisLockLinearY
bool axisLockLinearY [@property getter]
bool axisLockLinearY [@property setter]
Lock the body's movement in the x-axis.
- axisLockLinearZ
bool axisLockLinearZ [@property getter]
bool axisLockLinearZ [@property setter]
Lock the body's movement in the x-axis.
- bounce
double bounce [@property getter]
double bounce [@property setter]
- canSleep
bool canSleep [@property getter]
bool canSleep [@property setter]
If true the RigidBody will not calculate forces and will act as a static body while there is no movement. It will wake up when forces are applied through other collisions or when the apply_impulse method is used.
- contactMonitor
bool contactMonitor [@property getter]
bool contactMonitor [@property setter]
If true the RigidBody will emit signals when it collides with another RigidBody.
- contactsReported
long contactsReported [@property getter]
long contactsReported [@property setter]
The maximum contacts to report. Bodies can keep a log of the contacts with other bodies, this is enabled by setting the maximum amount of contacts reported to a number greater than 0.
- continuousCd
bool continuousCd [@property getter]
bool continuousCd [@property setter]
If true continuous collision detection is used.
Continuous collision detection tries to predict where a moving body will collide, instead of moving it and correcting its movement if it collided. Continuous collision detection is more precise, and misses less impacts by small, fast-moving objects. Not using continuous collision detection is faster to compute, but can miss small, fast-moving objects.
- customIntegrator
bool customIntegrator [@property getter]
bool customIntegrator [@property setter]
If true internal force integration will be disabled (like gravity or air friction) for this body. Other than collision response, the body will only move as determined by the _integrateForces function, if defined.
- friction
double friction [@property getter]
double friction [@property setter]
The body's friction, from 0 (frictionless) to 1 (max friction).
- gravityScale
double gravityScale [@property getter]
double gravityScale [@property setter]
This is multiplied by the global 3D gravity setting found in "Project > Project Settings > Physics > 3d" to produce RigidBody's gravity. E.g. a value of 1 will be normal gravity, 2 will apply double gravity, and 0.5 will apply half gravity to this object.
- linearDamp
double linearDamp [@property getter]
double linearDamp [@property setter]
The body's linear damp. Default value: -1, cannot be less than -1. If this value is different from -1, any linear damp derived from the world or areas will be overridden.
- linearVelocity
Vector3 linearVelocity [@property getter]
Vector3 linearVelocity [@property setter]
The body's linear velocity. Can be used sporadically, but DON'T SET THIS IN EVERY FRAME, because physics may run in another thread and runs at a different granularity. Use _integrateForces as your process loop for precise control of the body state.
- mass
double mass [@property getter]
double mass [@property setter]
- mode
RigidBody.Mode mode [@property getter]
long mode [@property setter]
The body mode from the MODE_* enum. Modes include: MODE_STATIC, MODE_KINEMATIC, MODE_RIGID, and MODE_CHARACTER.
- physicsMaterialOverride
PhysicsMaterial physicsMaterialOverride [@property getter]
PhysicsMaterial physicsMaterialOverride [@property setter]
- sleeping
bool sleeping [@property getter]
bool sleeping [@property setter]
If true the body is sleeping and will not calculate forces until woken up by a collision or the apply_impulse method.
- weight
double weight [@property getter]
double weight [@property setter]
The body's weight based on its mass and the global 3D gravity. Global values are set in "Project > Project Settings > Physics > 3d".
Physics Body whose position is determined through physics simulation in 3D space.
This is the node that implements full 3D physics. This means that you do not control a RigidBody directly. Instead you can apply forces to it (gravity, impulses, etc.), and the physics simulation will calculate the resulting movement, collision, bouncing, rotating, etc. A RigidBody has 4 behavior modes: Rigid, Static, Character, and Kinematic. Note: Don't change a RigidBody's position every frame or very often. Sporadic changes work fine, but physics runs at a different granularity (fixed hz) than usual rendering (process callback) and maybe even in a separate thread, so changing this from a process loop will yield strange behavior. If you need to directly affect the body's state, use _integrateForces, which allows you to directly access the physics state. If you need to override the default physics behavior, you can write a custom force integration. See customIntegrator.