ProtectedconstructorOptionalisInternalConstructor: booleanActivates or deactivates the component.
The returned active state also accounts for the active state of the parent SceneObject.
Determines the angular drag of the body. Higher drag values means the object resists angular movement more.
Determines the rigidbody's center of mass. This will be calculated automatically if the RigidbodyFlag::AutoCenterOfMass
flag is set.
Changing this property will unset the RigidbodyFlag::AutoCenterOfMass flag and override the automatically calculated
value. To revert back to automatic center of mass calculation, set the RigidbodyFlag::AutoCenterOfMass again using rigidbodyFlags.
Determines the linear drag of the body. Higher drag values means the object resists linear movement more.
Various flags set on the component that affect it's behavior.
Determines the rigidbody's inertia tensor, together with inertiaTensorRotation. The inertia tensor determines how
much the rigidbody will resist angular forces, similar to how the mass determines how much the rigidbody resists linear forces.
The rotational part of the tensor determines the three main rotation axes of the body. The diagonal part determines how much
the body resists angular forces around each of these axes. This will be calculated automatically if the RigidbodyFlag::AutoInertiaTensor
flag is set.
Changing this property will unset the RigidbodyFlag::AutoInertiaTensor flag and override the automatically calculated
value. To revert back to automatic inertai tensor calculation, set the RigidbodyFlag::AutoInertiaTensor again using rigidbodyFlags.
Determines the rigidbody's inertia tensor, together with inertiaTensorRotation. The inertia tensor determines how
much the rigidbody will resist angular forces, similar to how the mass determines how much the rigidbody resists linear forces.
The rotational part of the tensor determines the three main rotation axes of the body. The diagonal part determines how much
the body resists angular forces around each of these axes. This will be calculated automatically if the RigidbodyFlag::AutoInertiaTensor
flag is set.
Changing this property will unset the RigidbodyFlag::AutoInertiaTensor flag and override the automatically calculated
value. To revert back to automatic inertai tensor calculation, set the RigidbodyFlag::AutoInertiaTensor again using rigidbodyFlags.
Determines whether the component itself is active, without accounting for the active state of the parent scene object.
Determines if the object has been destroyed.
Determines if the body is kinematic. Kinematic body will not move in response to external forces (for example gravity, or another object pushing it), essentially behaving like collider. Unlike a collider though, you can still move the object and have other dynamic objects respond correctly (meaning it will push other objects).
Determines if the component is currently active, enabled and running.
Checks if the body is sleeping. Objects that aren't moved/rotated for a while are put to sleep to reduce load on the physics system.
Determines which transform axes of the rigidbody are locked.
Determines the mass of the entire rigidbody. If the RigidbodyFlag::AutoMass flag is set, then this is the sum of the masses
of all attached collider shapes.
Changing this property will unset the RigidbodyFlag::AutoMass and override the collider masses. To go back to automatic
mass calculation, set the RigidbodyFlag::AutoMass flag again using rigidbodyFlags.
Determines the maximum angular velocity of the rigidbody. Velocity will be clamped to this value.
Determines the cases that will trigger the onTransformChanged event.
Returns the PhysicsScene this node is being simulated on.
Determines the number of iterations to use when solving for position. Higher values can improve precision and numerical stability of the simulation.
The signed execution priority of the component.
Determines order of execution of this component in relation to other components, higher priorities will execute earlier.
The priority value determines the order of initialize, enable and update calls.
Valid priorities are in the range [-100...100], other priorities are reserved for internal use.
The priority should not be modified after onCreate has been called.
The default priority for user implement components is -10. BuiltinComponent have a default priority of 0. However, instances that have dependencies or are a dependency to another component might have non zero default priorities. For example, the Camera component has a default priority of 50 as other components may depend on the camera being initialized early. The Rigidbody component has a default priority of 22 and Joint components have a priority of 20 as the joint depends on fully initialized rigid bodies.
Flags that control the behaviour of the rigidbody.
Returns the SceneInstance this node is attached to.
Returns the SceneObject this component is attached to.
Determines whether or not the rigidbody will have the global gravity force applied to it.
Returns a universally unique identifier that persists scene save/load.
Determines the number of iterations to use when solving for velocity. Higher values can improve precision and numerical stability of the simulation.
Destroys the component, removing it from its scene object and stopping component updates.
Optionalimmediate: boolean
If true the component will be fully destroyed immediately. This means that objects that are still referencing this component might fail. Normally destruction is delayed until the end of the frame to give other objects a chance to stop using it.
Checks if the component has a specific ComponentFlag bit flag set.
The flag to check.
Calls a parameterless method with the specified name, on the component.
Name of the method to call.
true if the method was invoked.
ProtectedonProtectedonProtectedonVirtual
Called every time a component is placed into the Stopped state.
This method may be called during component destruction, if the component wasn't already in ScenePlayState.Stopped state during destruction. When called during destruction, it is called before onDestroy.
ProtectedonVirtual
Called every time a component leaves the ScenePlayState.Stopped state.
This method might be called during component creation, if the requirements for leaving the stopped state are met. One such case would be a component class that has the runInEditor attribute. When called during creation it is called after onInitialize.
Called at fixed time intervals (e.g. 60 times per frame). Only called if the component is in ScenePlayState.Playing state.
ProtectedonVirtual
Called once when the component first leaves the ScenePlayState.Stopped state.
This method might be called during component creation, if the requirements for leaving the stopped state are met. One such case would be a component class that has the runInEditor attribute. When called during creation it is called after onCreate.
Virtual
Called once per frame, after all other components received their onUpdate invocation. Only called if the component is in ScenePlayState.Playing state.
This method should only be implemented if your component needs logic that implements on other component or SceneObject changes performend in onUpdate. An example could be a camera controller logic that updates in response to changes to the object that is being tracked.
ProtectedonVirtual
Called when the script domain has been refreshed or when the component is initialized. During initialization it is called after onInitialize but before onEnable.
ProtectedonVirtual
Called when the component's parent SceneObject has changed.
The transform flags.
This method is only called if TransformChangedFlag.Transform is set on the Component#notifyFlags. The method will also not be called if the component is currently in the ScenePlayState.Stopped state.
To get the event for editor components that are active outside the simulation, attach the runInEditor attribute to your component class.
Virtual
Called once per frame. Only called if the component is in ScenePlayState.Playing state.
Rotates the rigidbody. This method will ensure physically correct rotation, meaning the body will collide with other objects along the way.
Sets or unsets the specified ComponentFlag bit flag on the instance.
The flag to set.
True to set the flag.
Forces the object to sleep. Useful if you know the object will not move in any significant way for a while.
Registers the coroutine for the specified component using the provided args as arguments.
true if the coroutine was registered.
The coroutine will be called for the first time when the coroutine subsystem runs for update events.
There is no guarantee with regards to the order of how coroutines are invoked.
Coroutines are a great way for time-deferred or delayed system. To implement a coroutine simply add a
generator method to your component and register it as coroutine:
public *myCoroutine(text:string)
{
const endTime:number = Time.realElapsed + 3;
while(Time.realElapsed < endTime)
{
yield true;
}
Debug.log("This code will be invoked after 3 seconds with the text=" + text);
}
To register the function simply call
this.startCoroutine(this.myCoroutine, "Hello World!");
The function will be invoked once the coroutine runs. The coroutine function can yield the program
control flow by using the keyword yield. The coroutine will then stop execution at that point,
and pick up the execution in the next update event, right after the yield keyword that caused
the coroutine to pause.
With helper functions such as waitForSeconds or waitForAsyncOp it is easy to create coroutines that pause for a set time interval.
Registers the coroutine for the specified component using the provided args as arguments.
true if the coroutine was registered.
The coroutine will be called for the first time when the coroutine subsystem runs for fixedUpdate events.
There is no guarantee with regards to the order of how coroutines are invoked.
Coroutines are a great way for time-deferred or delayed system. To implement a coroutine simply add a
generator method to your component and register it as coroutine:
public *myCoroutine(text:string)
{
const endTime:number = Time.realElapsed + 3;
while(Time.realElapsed < endTime)
{
yield true;
}
Debug.log("This code will be invoked after 3 seconds!");
}
To register the function simply call
this.startCoroutine(this.myCoroutine, "Hello World!");
The function will be invoked once the coroutine runs. The coroutine function can yield the program
control flow by using the keyword yield. The coroutine will then stop execution at that point,
and pick up the execution in the next fixedUpdate event, right after the yield keyword that caused
the coroutine to pause.
With helper functions such as waitForSeconds or waitForAsyncOp it is easy to create coroutines that pause for a set time interval.
Stops the coroutine for the specified component.
The coroutine to stop.
true if the coroutine was registered.
Returns a string representation of an object.
Wakes an object up. Useful if you modified properties of this object, and potentially surrounding objects which might result in the object being moved by physics (although the physics system will automatically wake the object up for majority of such cases).
StaticgetLocates a rsx object by its sceneRuntimeID and UUID.
The runtime ID of the SceneInstance of the object.
The UUID of the object to retrieve.
The object or null if no object with given sceneRuntimeID and uuid has been registered
ReadonlyonTriggered when one of the colliders owned by the rigidbody starts colliding with another object.
ReadonlyonTriggered when a previously colliding collider stays in collision. Triggered once per frame.
ReadonlyonTriggered when one of the colliders owned by the rigidbody stops colliding with another object.
Rigidbody is a dynamic physics object that can be moved using forces (or directly). It will interact with other static and dynamic physics objects in the scene accordingly (it will push other non-kinematic rigidbodies, and collide with static objects).
The shape and mass of a rigidbody is governed by its colliders. You must attach at least one collider for the rigidbody to be valid.
Example