Unigine.Physics Class
Controls the simulation of physics. For more information on principles and implementation of physics in real-time rendering, see the articles Execution Sequence, Physics and Simulation of Physics.
See Also#
- The Creating a Car with Suspension Joints usage example demonstrating how to set up physics parameters
- A set of UnigineScript API samples located in the <UnigineSDK>/data/samples/physics/ folder
Physics Class
Enums
UPDATE_MODE#
Physics update mode.Name | Description |
---|---|
BEFORE_RENDERING = 0 | Update Before Rendering. Physics update (along with the spatial tree update and user callbacks) is executed in the Main thread just before rendering is performed (render). The number of physics ticks executed before the rendering frame here is defined by the physics and the Engine framerates. This mode is the most clear and straightforward (everything is executed safely in a strictly determined order) with no frame lag (results of physics calculations are applied in the current frame). But, on the other hand, this mode is the slowest as there are no asynchronous parallel calculations (everything's in the Main thread). Use this mode in case the time lag is unacceptabe for your application (you need all physics calculations to be applied in the current frame) and you want maximum simplicity and strictly determined order of execution for user code (physicsUpdate and physics callbacks). |
ASYNC_RENDERING = 1 | Asynchronous update mode. Physics update is performed asynchronously to rendering. In case of several physics ticks per one rendering frame (when the Engine framerate is lower, or catching up is performed), only the first one is executed in parallel, then the physics module waits for the completion of the rendering process, returns to the Main thread and executes the rest of the physics ticks. There is a frame lag (results of physics calculations are applied in the next frame) and there is some ambiguity regarding the time, when user code (physicsUpdate and physics callbacks) is to be executed in case of several physics ticks per one rendering frame (some part is executed before rendering while the other just after it). This mode is the fastest one and is used by default. |
Properties
float TotalTime#
float SimulationTime#
float ResponseTime#
int NumJoints#
int NumIslands#
int NumContacts#
int NumBodies#
float CollisionTime#
float IntegrateTime#
int Frame#
int NumIterations#
int NumFrozenFrames#
float CurrentSubframeTime#
float Scale#
float PenetrationTolerance#
float PenetrationFactor#
float MaxLinearVelocity#
float MaxAngularVelocity#
float LinearDamping#
float IFps#
vec3 Gravity#
float FrozenLinearVelocity#
float FrozenAngularVelocity#
float AngularDamping#
float Distance#
float Budget#
string Data#
bool SyncEngineUpdateWithPhysics#
bool Determinism#
Please note that deterministic mode does not come for free, it may eat up 10-20% of the frame rate, and it also depends on the scene a lot.
bool Enabled#
float MissedFrameLifetime#
Physics.UPDATE_MODE UpdateMode#
bool StableFPS#
Members
Body GetBody ( int id ) #
Returns a body with a given ID.Arguments
- int id - Body ID.
Return value
Body with a given ID or NULL (0), if there is no body with a given ID.int IsBody ( int id ) #
Checks if a body with a given ID exists.Arguments
- int id - Body ID.
Return value
1 if a body with a given ID exists; otherwise, 0.Object GetIntersection ( vec3 p0, vec3 p1, int mask, Node[] exclude, PhysicsIntersection intersection ) #
Performs tracing from the p0 point to the p1 point to find a collision object located on that line. If an object is assigned a body, intersection occurs with its shape. If an object has no body, this function detects intersection with surfaces (polygons) of objects with intersection flag set. Intersection is found only for objects with a matching mask if their ID is not found in the exclude list. Intersection is Intersection does not work for disabled objects.
Arguments
- vec3 p0 - Line start point coordinates.
- vec3 p1 - Line end point coordinates.
- int mask - Physics intersection mask. If 0 is passed, the function will return NULL.
- Node[] exclude - Array of nodes to be excluded.
- PhysicsIntersection intersection - PhysicsIntersection class instance containing intersection data.
Return value
The first intersected object, if found; otherwise, 0.Object GetIntersection ( vec3 p0, vec3 p1, int mask, PhysicsIntersection intersection ) #
Performs tracing from the p0 point to the p1 point to find a collision object located on that line. If an object is assigned a body, intersection occurs with its shape. If an object has no body, this function detects intersection with surfaces (polygons) of objects with intersection flag set. Physics intersection shall only be detected for objects with a matching mask. Intersection does not work for disabled objects.
Usage Example
The following example shows how you can get the intersection information by using the PhysicsIntersection class. In this example we specify a line from the point of the camera (vec3 p0) to the point of the mouse pointer (vec3 p1). The executing sequence is the following:
- Define and initialize two points (p0 and p1) by using the Player.GetDirectionFromScreen() function.
- Create an instance of the PhysicsIntersection class to get the intersection information.
- Check, if there is an intersection with an object with a shape or a collision object. The GetIntersection() function returns an intersected object when the object intersects with the traced line.
- When the object intersects with the traced line, all surfaces of the intersected object change their material parameters. If the object has a shape, its information will be shown in console. The PhysicsIntersection class instance gets the coordinates of the intersection point and the Shape class object. You can get all these fields by using the Shape, Point properties.
private void Update()
{
// initialize points of the mouse direction
Vec3 p0, p1;
// get the current player (camera)
Player player = Game.Player;
// get the size of the current application window
EngineWindow main_window = WindowManager.MainWindow;
if (!main_window)
{
Engine.Quit();
return;
}
ivec2 main_size = main_window.Size;
// get the current X and Y coordinates of the mouse pointer
int mouse_x = Gui.GetCurrent().MouseX;
int mouse_y = Gui.GetCurrent().MouseY;
// get the mouse direction from the player's position (p0) to the mouse cursor pointer (p1)
player.GetDirectionFromScreen(out p0, out p1, mouse_x, mouse_y, 0, 0, main_size.x, main_size.y);
// create the instance of the PhysicsIntersection object to save the information about the intersection
PhysicsIntersection intersection = new PhysicsIntersection();
// get an intersection
Unigine.Object obj = Physics.GetIntersection(p0, p1, 1, intersection);
// if the intersection has occurred, change the parameter of the object's material
if (obj != null)
{
for (int i = 0; i < obj.NumSurfaces; i++)
{
obj.SetMaterialParameterFloat4("albedo_color", new vec4(1.0f, 1.0f, 0.0f, 1.0f), i);
}
// if the intersected object has a shape, show the information about the intersection
Shape shape = intersection.Shape;
if (shape != null)
{
Log.Message("physics intersection info: point: ({0} {1} {2}) shape: {3}\n", intersection.Point.x, intersection.Point.y, intersection.Point.z, shape.TypeName);
}
}
}
Arguments
- vec3 p0 - Line start point coordinates.
- vec3 p1 - Line end point coordinates.
- int mask - Physics intersection mask. If 0 is passed, the function will return NULL.
- PhysicsIntersection intersection - PhysicsIntersection class instance containing intersection data.
Return value
The first intersected object, if found; otherwise, 0.Object GetIntersection ( vec3 p0, vec3 p1, int mask, PhysicsIntersectionNormal intersection ) #
Performs tracing from the p0 point to the p1 point to find a collision object located on that line. If an object is assigned a body, intersection occurs with its shape. If an object has no body, this function detects intersection with surfaces (polygons) of objects with intersection flag set. Physics intersection shall only be detected for objects with a matching mask. Intersection does not work for disabled objects.
Arguments
- vec3 p0 - Line start point coordinates.
- vec3 p1 - Line end point coordinates.
- int mask - Physics intersection mask. If 0 is passed, the function will return NULL.
- PhysicsIntersectionNormal intersection - PhysicsIntersectionNormal class instance containing intersection data.
Return value
The first intersected object, if found; otherwise, 0.Object GetIntersection ( vec3 p0, vec3 p1, int mask, Node[] exclude, PhysicsIntersectionNormal intersection ) #
Performs tracing from the p0 point to the p1 point to find a collision object located on that line. If an object is assigned a body, intersection occurs with its shape. If an object has no body, this function detects intersection with surfaces (polygons) of objects with intersection flag set. Intersection is found only for objects with a matching mask if their ID is not found in the exclude list. Intersection is Intersection does not work for disabled objects.
Arguments
- vec3 p0 - Line start point coordinates.
- vec3 p1 - Line end point coordinates.
- int mask - Physics intersection mask. If 0 is passed, the function will return NULL.
- Node[] exclude - Array of nodes to be excluded.
- PhysicsIntersectionNormal intersection - PhysicsIntersectionNormal class instance containing intersection data.
Return value
The first intersected object, if found; otherwise, 0.Joint GetJoint ( int id ) #
Returns a joint with a given ID.Arguments
- int id - Joint ID.
Return value
Joint with a given ID or NULL (0), if there is no joint with a given ID.int IsJoint ( int id ) #
Checks if a joint with a given ID exists.Arguments
- int id - Joint ID.
Return value
1 if a joint with a given ID exists; otherwise, 0.Shape GetShape ( int id ) #
Returns a shape with a given ID.Arguments
- int id - Shape ID.
Return value
Shape with a given ID or NULL (0), if there is no shape with a given ID.int IsShape ( int id ) #
Checks if a shape with a given ID exists.Arguments
- int id - Shape ID.
Return value
1 if a shape with a given ID exists; otherwise, 0.void AddUpdateNode ( Node node ) #
Adds the node for which physical state should be updated. If a node is not added with this function, it won't be updated when out of physics simulation distance.Arguments
- Node node - Node to be updated.
void addUpdateNodes ( Node[] nodes ) #
Adds the nodes for which physical state should be updated. If nodes are not added with this function, they won't be updated when out of physics simulation distance.Arguments
- Node[] nodes - Nodes to be updated.
int LoadSettings ( string name, bool clear = false ) #
Loads the physics settings from a given file.Arguments
- string name - Path to an XML file with desired settings.
- bool clear - Clear flag. Set true to clear settings before loading (new settings shall be applied right after loading them), or false not to clear.
Return value
Returns 1 if the settings are loaded successfully; otherwise, 0.int LoadWorld ( Xml xml ) #
Loads physics settings from the Xml.Arguments
- Xml xml - Xml node.
Return value
Returns 1 if settings are loaded successfully; otherwise, 0.int SaveScene ( ) #
Saves the current physics scene (physical properties of all objects) into the buffer.Return value
Scene buffer ID.int RestoreScene ( int id ) #
Restores the previously saved physics scene from the buffer.Arguments
- int id - ID number of the scene.
Return value
Returns 1 if the scene is restored successfully; otherwise, 0.int RemoveScene ( int id ) #
Removes the previously saved physics scene.Arguments
- int id - ID number of the scene.
Return value
Returns 1 if the scene is removed successfully; otherwise, 0.bool SaveState ( Stream stream ) #
Saves physics settings into the stream.Example using saveState() and restoreState() methods:
// set state
Physics.NumIterations = 1; // NumIterations = 1
// save state
Blob blob_state = new Blob();
Physics.SaveState(blob_state);
// change state
Physics.NumIterations = 16; // now NumIterations = 16
// restore state
blob_state.SeekSet(0); // returning the carriage to the start of the blob
Physics.RestoreState(blob_state); // restore NumIterations = 1
Arguments
- Stream stream - Stream to save settings into.
Return value
true if settings are saved successfully; otherwise, false.bool RestoreState ( Stream stream ) #
Restores physics settings from the stream.Example using saveState() and restoreState() methods:
// set state
Physics.NumIterations = 1; // NumIterations = 1
// save state
Blob blob_state = new Blob();
Physics.SaveState(blob_state);
// change state
Physics.NumIterations = 16; // now NumIterations = 16
// restore state
blob_state.SeekSet(0); // returning the carriage to the start of the blob
Physics.RestoreState(blob_state); // restore NumIterations = 1
Arguments
- Stream stream - Stream to restore settings from.
Return value
true if settings are restored successfully; otherwise, false.bool SaveSettings ( string name, int force = 0 ) #
Saves the current physics settings to a given file.Arguments
- string name - Path to a target file.
- int force - Forced saving of physics settings.
Return value
true if the settings are saved successfully; otherwise, false.bool SaveWorld ( Xml xml, int force = 0 ) #
Saves physics settings to the given Xml node.Arguments
- Xml xml - Xml node.
- int force - Forced saving of physics settings.