Omni PhysX

Overview

The omni.physx extension provides a connection between USD physics content and the NVIDIA PhysX simulation engine. Physics content in USD is defined through two USD schemas: UsdPhysics which implements the standard USD physics extension schema, and PhysXSchema, which extends it with PhysX specific features.

The omni.physx plugin is responsible for parsing the USD stage, running the PhysX simulation, and writing the results back to the USD stage.

Working with Physics

Physics is activated when the play button is pressed in Omniverse Create, which leads to the following sequence of events:

The USD stage is parsed and physics objects are created within PhysX. This is a blocking call, so Create will freeze for a bit. This is a known issue and will be resolved at a later stage.

If required, PhysX cooking and convex decomposition is executed depending on mesh approximation USD schema attributes. The results of the cooking are cached in the USD stage file, so if the USD Stage is saved, the cooking doesn’t need to be repeated.

In addition, cooked data is also cached in the workstation’s local cache, so recomputation is sometimes also avoided even when the USD stage is not saved.

Simulation starts once parsing is complete.

Simulation output is written to USD. By default, transformations and velocities (in local space) are written to USD. It’s possible to toggle this behavior in the Physics settings window.

Omni.physx listens to USD changes, and changes are applied to PhysX while the simulation is running.

Simulation Output

Physics simulation outputs by default transformations and velocities into USD, on larger scenes this can be very slow. However it is possible to speed up the transformation updates for rendering. In Extensions window enable omni.physx.fabric extension:

Simulation wont write to USD, but it will use fabric to update transformation and velocities. Note that this extensions is still under development and not all features are supported.

Note that if transformations are written only to fabric, they are not visible for the UI. It is possible to get the rigid body transformation through a IPhysX interface that does have python bindings. (see the python bindings documentation for get_rigidbody_transformation)

USD Physics Schema

The UsdPhysics schema has been developed in a collaboration between Pixar, Apple and NVIDIA. The specification can be found on the Pixar USD website as well as here in our USD schema documentation . It is recommended that the reader familiarize themselves with this important document that explains all the basic concepts in detail.

USD Physics Python Tutorials

These tutorial snippets show Physics usage through the use of the Python USD API. Note that most of the Python code here can also be found in the Physics Python demo script files.

Setting up a USD Stage and a Physics Scene

In this tutorial, a USD stage and a Physics scene are created using python APIs. By default, all bodies in the USD stage with a PhysicsScene are simulated. Without a scene, simulation will not occur. Multiple scenes per stage will be supported by Omniverse in the future.

A physics scene is represented as a PhysicsScene typed USD Prim in the Physics schema. All the required imports are also defined in this snippet and are to be re-used in the following snippets.

Note that this generates USD state as output which is then parsed as discussed above. To see the generated USD state, save the stage in text .usda format and view it in a text editor.

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf

# Set up a USD Stage to define what is the up axis and set up the units,
# which is crucial, as some default simulation parameters are derived
# from the MetersPerUnit value
stage = omni.usd.get_context().get_stage()
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
UsdGeom.SetStageMetersPerUnit(stage, 0.01)

# Physics scene definition
scene = UsdPhysics.Scene.Define(stage, "/physicsScene")

# setup gravity
# note that gravity has to respect the selected units, if we are using cm, the gravity has to respect that
scene.CreateGravityDirectionAttr().Set(Gf.Vec3f(0.0, 0.0, -1.0))
scene.CreateGravityMagnitudeAttr().Set(981.0)

Creating Colliders

In this tutorial a static collider is created. Colliders are represented using the UsdPhysicsCollisionAPI applied schema. The schema must be applied to a geom prim. Based on the geom prim’s type, an appropriate collider is created in Physics. For mesh prims it is recommended to use UsdPhysicsMeshCollisionAPI to define mesh approximations of various types.

This code is meant to follow the stage and scene creation in the preceeding tutorial, it won’t work without that state being set up first.

# Cube path
cubeActorPath = "/cubeActor"

# Cube parameters like size, position, orientation
size = 25.0
position = Gf.Vec3f(0.0, 0.0, 500.0)
orientation = Gf.Quatf(1.0)
color = Gf.Vec3f(71.0 / 255.0, 105.0 / 255.0, 1.0)

# define the cube geom
cubeGeom = UsdGeom.Cube.Define(stage, cubeActorPath)
cubeGeom.CreateSizeAttr(size)
cubeGeom.AddTranslateOp().Set(position)
cubeGeom.AddOrientOp().Set(orientation)
cubeGeom.AddScaleOp().Set(Gf.Vec3f(1.0))
cubeGeom.CreateDisplayColorAttr().Set([color])

# get the prim
cubePrim = stage.GetPrimAtPath(cubeActorPath)

# setup collision, so that the cube does collider
UsdPhysics.CollisionAPI.Apply(cubePrim)

Different Collision and Rendering Representations

It is possible to have different collision and rendering representations. Two different geom prims have to be created, where one will serve for collision and the other for rendering. The parent xform of both prims should be the rigid body so they move together, and the collision geom prim should have the purpose “guide” set so it is not rendered.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

# Top level actor, contains rigid body
rigidCompoundPath = "/compoundRigid"
rigidXform = UsdGeom.Xform.Define(stage, rigidCompoundPath)
rigidPrim = stage.GetPrimAtPath(rigidCompoundPath)

# Rigid body transform
rigidCompoundPos = Gf.Vec3f(0.0, 0.0, 10.0)
rigidXform.AddTranslateOp().Set(rigidCompoundPos)
rigidXform.AddOrientOp().Set(Gf.Quatf(1.0, 0.0, 0.0, 0.0))

physicsAPI = UsdPhysics.RigidBodyAPI.Apply(rigidPrim)

# Collision shape
collisionShape = rigidCompoundPath + "/physicsBoxShape"

size = 25.0
shapePos = Gf.Vec3f(0.0)
shapeQuat = Gf.Quatf(1.0)

cubeGeom = UsdGeom.Cube.Define(stage, collisionShape)
cubePrim = stage.GetPrimAtPath(collisionShape)
cubeGeom.CreateSizeAttr(size)
cubeGeom.AddTranslateOp().Set(shapePos)
cubeGeom.AddOrientOp().Set(shapeQuat)

# set it as collision
UsdPhysics.CollisionAPI.Apply(cubePrim)

# hide it from rendering
cubeGeom.CreatePurposeAttr(UsdGeom.Tokens.guide)

# rendering shape
renderSphere = rigidCompoundPath + "/renderingSphere"

sphereGeom = UsdGeom.Sphere.Define(stage, renderSphere)
#sphereGeom.CreateSizeAttr(20.0)
sphereGeom.AddTranslateOp().Set(shapePos)
sphereGeom.AddOrientOp().Set(shapeQuat)

Physics Materials

Each collider can have a different physics material assigned. UsdPhysicsMaterialAPI can be applied to any other material, and this API adds physics material propertie like static/dynamic friction. To assign a material to a collider use material binding with a purpose of “physics”.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

Example

# define physics material
materialPath = "/material"
mu = 1.0
UsdShade.Material.Define(stage, materialPath)
material = UsdPhysics.MaterialAPI.Apply(stage.GetPrimAtPath(materialPath))
material.CreateStaticFrictionAttr().Set(mu)
material.CreateDynamicFrictionAttr().Set(mu)
material.CreateRestitutionAttr().Set(0.0)
material.CreateDensityAttr().Set(1000.0)

collisionAPI = UsdPhysics.CollisionAPI.Get(stage, collisionShape)

# add the material to the collider
bindingAPI = UsdShade.MaterialBindingAPI.Apply(collisionAPI.GetPrim())
materialPrim = material.GetPrim()
material = UsdShade.Material(materialPrim)
bindingAPI.Bind(material, UsdShade.Tokens.weakerThanDescendants, "physics")

Using Convex Mesh for Cylinder and Cone Collision

UsdGeom.Cylinder and UsdGeom.Cone prims’ collision is by default approximated as custom geometry for higher precision. However, you can set them to use convex mesh instead by disabling the corresponding toggles in the Physics settings under the collision section.

Note: you can also use the Omniverse Create built-in cone and cylinder mesh geometries for convex approximation. This allows you to fine grain control whether individual geometry should be simulated with a convex approximation or custom geometry collider.

Rigid Bodies

In this tutorial we create a cube geom primitive that will be simulated as a rigid body. A rigid body is represented in the Physics schema as UsdPhysicsRigidBodyAPI schema applied to an xformable Prim.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

# Cube path
cubeActorPath = "/cubeActorRigid"

# Cube parameters like size, position, orientation
size = 25.0
position = Gf.Vec3f(0.0, 0.0, 500.0)
orientation = Gf.Quatf(1.0)
color = Gf.Vec3f(71.0 / 255.0, 105.0 / 255.0, 1.0)

# initial velocities
linVelocity = Gf.Vec3f(2.0, 1.0, 2.0)
angularVelocity = Gf.Vec3f(1.0, 0.0, 0.0)

# define the cube geom
cubeGeom = UsdGeom.Cube.Define(stage, cubeActorPath)
cubeGeom.CreateSizeAttr(size)
cubeGeom.AddTranslateOp().Set(position)
cubeGeom.AddOrientOp().Set(orientation)
cubeGeom.AddScaleOp().Set(Gf.Vec3f(1.0))
cubeGeom.CreateDisplayColorAttr().Set([color])

# get the prim
cubePrim = stage.GetPrimAtPath(cubeActorPath)

# setup collision, so that the cube does collider
UsdPhysics.CollisionAPI.Apply(cubePrim)

# setup physics - rigid body
rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(cubePrim)

# apply initial velocities
rigidBodyAPI.CreateVelocityAttr().Set(linVelocity)
rigidBodyAPI.CreateAngularVelocityAttr().Set(angularVelocity)

During simulation, if you want to change linear velocity of a rigid body, you have to change the velocity attribute of UsdPhysicsRigidBodyAPI:

rigidBodyAPI.CreateVelocityAttr().Set(newVelocity)

Difference Between a Static Body and a Dynamic Body

If a Geom Prim with a UsdPhysicsCollisionAPI is found, it can belong either to a static or a dynamic body. The logic to decide goes like this:

If there is no UsdPhysicsRigidBodyAPI applied on the prim or on any parent Prim in the hierarchy, then the geom with the UsdPhysicsCollisionAPI is considered a static body.

Else:

If physics:rigidBodyEnabled attribute is true (default) then the geom belongs to a dynamic body.

Else the Geom belongs to a static body.

Kinematic Body

If a body needs to be driven by animation or user defined target positions, physics:kinematicEnabled attribute on UsdPhysicsRigidBodyAPI should be set to true.

CPU vs GPU Rigid Body Dynamics

By default, rigid body simulation is performed on the GPU. It is possible to override the pipeline in the Physics Debug window or using scene attributes. In order to use CPU simulation, please add a PhysxSceneAPI to the UsdPhysicsScene prim and set these attributes:

physxScene:broadphaseType - MBP

physxScene:enableGPUDynamics - False

For GPU simulation the first setting is GPU and the second is True.

Rigid Body Mass Properties

UsdPhysicsMassAPI defines the mass properties of a rigid body. UsdPhysicsMassAPI can be applied to either a prim with UsdPhysicsRigidBodyAPI or to a prim with USdPhysicsCollisionAPI. It provides various ways to define a mass properties for a rigid body:

physics:mass

Note that any child Prim can also have a mass when they apply UsdPhysicsMassAPI. In this case, the precedence rule is ‘parent mass overrides the child’s’. This may come as counter-intuitive, but mass is a computed quantity and in general not accumulative. For example, if a parent has mass of 10, and one of two children has mass of 20, allowing a child’s mass to override its parents would results in -10 for mass for the other child.

physics:density

In the context of rigid body physics, density indirectly results in setting mass via (mass = density x volume of the object). In the case where both density and mass are specified for the same object, mass has precedence over density. Unlike mass, a child prim’s density overrides a parent prim’s density. Note that the density of a collisionAPI can also alternatively be set through a physicsMaterial relation. The material density has the weakest precedence in density definition. Note that density respects units. So a water density is 1000 for metersPerUnit = 1 and 0.001 for metersPerUnit = 0.01.

physics:centerOfMass - Center of mass in prim’s local space.

physics:diagonalInertia - Diagonalized inertia tensor in un-rotated state.

physics:principalAxes - Orientation (quaternion) of the inertia tensor’s principal axes in the prim’s local space.

The parsing code does gather mass properties per collision shape and uses the computed inertia tensor to compute the final mass properties for the body. If no massAPI is found, the default density of 1000 is used to determine the final mass.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

Example of custom center of mass .. code:

# Cube path
cubeActorPath = "/cubeActorRigidMass"

# Cube parameters like size, position, orientation
size = 25.0
position = Gf.Vec3f(0.0, 0.0, 500.0)
orientation = Gf.Quatf(1.0)
color = Gf.Vec3f(71.0 / 255.0, 105.0 / 255.0, 1.0)

# define the cube geom
cubeGeom = UsdGeom.Cube.Define(stage, cubeActorPath)
cubeGeom.CreateSizeAttr(size)
cubeGeom.AddTranslateOp().Set(position)
cubeGeom.AddOrientOp().Set(orientation)
cubeGeom.AddScaleOp().Set(Gf.Vec3f(1.0))
cubeGeom.CreateDisplayColorAttr().Set([color])

# get the prim
cubePrim = stage.GetPrimAtPath(cubeActorPath)

# setup collision, so that the cube does collider
UsdPhysics.CollisionAPI.Apply(cubePrim)

# setup physics - rigid body, so that cube does simulate as a rigid body
UsdPhysics.RigidBodyAPI.Apply(cubePrim)

# custom center of mass
massAPI = UsdPhysics.MassAPI.Apply(cubePrim)
massAPI.CreateCenterOfMassAttr().Set(Gf.Vec3f(0.0, 0.0, 10.0))

Joints

Creating a Physics joint between two bodies or between a body and the world frame.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

# box0 static
boxActorPath = "/box0"

# box0 props
position = Gf.Vec3f(0.0, 0.0, 1000.0)
orientation = Gf.Quatf(1.0)
color = Gf.Vec3f(165.0 / 255.0, 21.0 / 255.0, 21.0 / 255.0)
size = 100.0
scale = Gf.Vec3f(0.1, 1.0, 0.1)

cubeGeom = UsdGeom.Cube.Define(stage, boxActorPath)
cubeGeom.CreateSizeAttr(size)
cubeGeom.AddTranslateOp().Set(position)
cubeGeom.AddOrientOp().Set(orientation)
cubeGeom.AddScaleOp().Set(scale)
cubeGeom.CreateDisplayColorAttr().Set([color])

# make it a static body - just apply PhysicsCollisionAPI
cubePrim = stage.GetPrimAtPath(boxActorPath)
UsdPhysics.CollisionAPI.Apply(cubePrim)

# Box1 dynamic body
boxActorPath = "/box1"

position = Gf.Vec3f(0.0, 120.0, 1000.0)
color = Gf.Vec3f(71.0 / 255.0, 165.0 / 255.0, 1.0)

cubeGeom = UsdGeom.Cube.Define(stage, boxActorPath)
cubeGeom.CreateSizeAttr(size)
cubeGeom.AddTranslateOp().Set(position)
cubeGeom.AddOrientOp().Set(orientation)
cubeGeom.AddScaleOp().Set(scale)
cubeGeom.CreateDisplayColorAttr().Set([color])

# setup dynamic rigid body
cubePrim = stage.GetPrimAtPath(boxActorPath)
UsdPhysics.CollisionAPI.Apply(cubePrim)
UsdPhysics.RigidBodyAPI.Apply(cubePrim)

# create revolute joint prim
revoluteJoint = UsdPhysics.RevoluteJoint.Define(stage, "/revoluteJoint")

# define revolute joint axis and its limits, defined in degrees
revoluteJoint.CreateAxisAttr("X")
revoluteJoint.CreateLowerLimitAttr(-90.0)
revoluteJoint.CreateUpperLimitAttr(90.0)

# define revolute joint bodies
revoluteJoint.CreateBody0Rel().SetTargets(["/box0"])
revoluteJoint.CreateBody1Rel().SetTargets(["/box1"])

# define revolute joint local poses for bodies
revoluteJoint.CreateLocalPos0Attr().Set(Gf.Vec3f(0.0, 60.0, 0.0))
revoluteJoint.CreateLocalRot0Attr().Set(Gf.Quatf(1.0))

revoluteJoint.CreateLocalPos1Attr().Set(Gf.Vec3f(0.0, -60.0, 0.0))
revoluteJoint.CreateLocalRot1Attr().Set(Gf.Quatf(1.0))

# set break force/torque
revoluteJoint.CreateBreakForceAttr().Set(1e20)
revoluteJoint.CreateBreakTorqueAttr().Set(1e20)

# optionally add angular drive for example
angularDriveAPI = UsdPhysics.DriveAPI.Apply(stage.GetPrimAtPath("/revoluteJoint"), "angular")
angularDriveAPI.CreateTypeAttr("force")
angularDriveAPI.CreateMaxForceAttr(1e20)
angularDriveAPI.CreateTargetVelocityAttr(1.0)
angularDriveAPI.CreateDampingAttr(1e10)
angularDriveAPI.CreateStiffnessAttr(0.0)

Joint Types

The currently supported joint types are:

Revolute joint

A joint with one angular degree of freedom enabled. To specify a revolute joint, define a RevolutePhysicsJoint Prim. A revolute joint is defined by an axis, if limit (lower/upper) attributes are not defined the movement around the axis is not restricted. Angular drive can be set on a revolute joint, DriveAPI has to be applied to the joint Prim. Note that DriveAPI is a multiple-applied schema, in order to define the angular drive for a revolute joint, the angular token is used to define the drive.

Prismatic joint

A joint with one linear degree of freedom enabled. To specify a prismatic joint, define a PrismaticPhysicsJoint Prim. A prismatic joint is defined by an axis, if the limit (lower/upper) attributes are not defined, the movement around the axis is not restricted. Linear drive can be set on a revolute joint, while DriveAPI has to be applied to the joint Prim. Note that DriveAPI is a multiple-applied schema, in order to define linear drive for a revolute joint, the angular token is used to define the drive.

Spherical joint

A joint with restricted linear degree of freedom, which behaves like a ball and socket. To specify a spherical joint, define a SphericalPhysicsJoint Prim. A spherical joint is defined by an axis and a cone limit.

Distance joint

A joint that allows movement in given min/max distance. To specify a distance joint, define a DistancePhysicsJoint Prim. A distance limit can separately define minDistance and maxDistance, limiting the movement between two bodies.

Fixed joint

Removes all degrees of freedom. To specify a fixed joint define a FixedPhysicsJoint Prim.

Generic D6 joint

If just a PhysicsJoint Prim exists, it is considered a generic D6 joint that has by default all degrees of freedom. Each degree of freedom can be limited by applying the LimitAPI. LimitAPI is a multiple-applied schema and the second token, does specify which axis should be limited. The ‘transX’, ‘transY’, ‘transZ’ tokens restrict linear degrees of freedom and ‘rotX’, ‘rotY’, ‘rotZ’ restrict angular degrees of freedom. The low/high attribute on the LimitAPI can be used to define whether the movement is limited or restricted. To restrict movement, set the low attribute to be larger than the high attribute. For each axis DriveAPI can be defined, use the same tokens as for limit to define where the DriveAPI should be applied.

Articulations

Articulations are tree structures of bodies connected by joints that are resolved as a unit by Physics.

How to Define Articulations

Articulations are defined by PhysicsJoints and their connected bodies. The parsing code is looking for UsdPhysicsArticulationRootAPI to identify articulation roots. There are two types of articulations:

Fixed root articulations, in this case the UsdPhysicsArticulationRootAPI should be defined on a joint to world, or a prim in its parent hierarchy.

Floating articulations, in this case the UsdPhysicsArticulationRootAPI should be defined on a rigidbody or a prim in its parent hierarchy.

This is an example of a simple articulation chain.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

radius = 1.0
halfHeight = 1.0
color = Gf.Vec3f(0.4, 0.2, 0.1)
nbBoxes = 15

initPos = Gf.Vec3f(0.0, 0.0, 24.0)
pos = Gf.Vec3f(0.0, 0.0, 0.0)

# setup the articulation as a parent of the hierarchy
UsdGeom.Xform.Define(stage, "/articulation")
UsdPhysics.ArticulationRootAPI.Apply(stage.GetPrimAtPath("/articulation"))

parentName = "/articulation"

# Create chain
for i in range(nbBoxes):
    # articulation link
    linkName = "/articulation/articulationLink" + str(i)

    # capsule geom
    capsuleGeom = UsdGeom.Capsule.Define(stage, linkName)
    capsulePrim = stage.GetPrimAtPath(linkName)
    capsuleGeom.CreateHeightAttr(halfHeight)
    capsuleGeom.CreateRadiusAttr(radius)
    capsuleGeom.CreateAxisAttr("X")
    capsuleGeom.AddTranslateOp().Set(initPos + pos)
    capsuleGeom.AddOrientOp().Set(Gf.Quatf(1.0))
    capsuleGeom.AddScaleOp().Set(Gf.Vec3f(1.0, 1.0, 1.0))
    capsuleGeom.CreateDisplayColorAttr().Set([color])

    # articulation link is just a regular rigid body
    UsdPhysics.CollisionAPI.Apply(capsulePrim)
    UsdPhysics.RigidBodyAPI.Apply(capsulePrim)

    if i != 0:
        articulatedJointName = "/articulation/articulatedRevoluteJoint" + str(i)

        # joint definition between the articulation links
        component = UsdPhysics.RevoluteJoint.Define(stage, articulatedJointName)
        val0 = [Sdf.Path(parentName)]
        val1 = [Sdf.Path(linkName)]

        if parentName != "":
            component.CreateBody0Rel().SetTargets(val0)
        component.CreateLocalPos0Attr().Set(Gf.Vec3f(radius + halfHeight, 0.0, 0.0))
        component.CreateLocalRot0Attr().Set(Gf.Quatf(1.0))

        component.CreateBody1Rel().SetTargets(val1)
        component.CreateLocalPos1Attr().Set(Gf.Vec3f(-(radius + halfHeight), 0.0, 0.0))
        component.CreateLocalRot1Attr().Set(Gf.Quatf(1.0))

        component.CreateBreakForceAttr().Set(sys.float_info.max)
        component.CreateBreakTorqueAttr().Set(sys.float_info.max)

        component.CreateAxisAttr("Y")
        component.CreateLowerLimitAttr(float(-3.14 / 32.0))
        component.CreateUpperLimitAttr(float(3.14 / 32.0))

    else:
        # create the root joint
        articulatedJointName = "/articulation/rootJoint"
        component = UsdPhysics.FixedJoint.Define(stage, articulatedJointName)

        val1 = [Sdf.Path(linkName)]
        component.CreateLocalPos0Attr().Set(initPos)
        component.CreateLocalRot0Attr().Set(Gf.Quatf(1.0))

        component.CreateBody1Rel().SetTargets(val1)
        component.CreateLocalPos1Attr().Set(Gf.Vec3f(0.0, 0.0, 0.0))
        component.CreateLocalRot1Attr().Set(Gf.Quatf(1.0))

        component.CreateBreakForceAttr().Set(sys.float_info.max)
        component.CreateBreakTorqueAttr().Set(sys.float_info.max)

    parentName = linkName
    pos[0] += (radius + halfHeight) * 2.0

Collision Filtering

There are two types of collision filtering, broad filtering using PhysicsCollisionGroups and fine grained filtering using the PhysicsFilteredPairsAPI schema API.

Using PhysicsCollisionGroups

PhysicsCollisionGroup is a prim type that has a CollectionAPI:colliders applied. Prims in this collection belong to that collision group. Each PhysicsCollisionGroup has a filteredGroups rel that defines what groups this CollisionGroup should not collide against by default.

This is an example of PhysicsCollisionGroup usage.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

from omni.physx.scripts.physicsUtils import *
from pxr import Usd, UsdGeom, Sdf, Gf, Tf, UsdPhysics

# add collision groups
cubesGroup = "/physicsScene/collisionGroupBoxes"
spheresGroup = "/physicsScene/collisionGroupSpheres"
collisionGroupCubes = UsdPhysics.CollisionGroup.Define(stage, cubesGroup)
collisionGroupSpheres = UsdPhysics.CollisionGroup.Define(stage, spheresGroup)

# setup groups so that they dont collide with each other
filteredRel = collisionGroupSpheres.CreateFilteredGroupsRel()
filteredRel.AddTarget(spheresGroup)

filteredRel = collisionGroupSpheres.CreateFilteredGroupsRel()
filteredRel.AddTarget(cubesGroup)

numActors = 20

# boxes/groupBoxes
boxActorsPath = "/boxActors"
UsdGeom.Xform.Define(stage, boxActorsPath)

size = 50.0
density = 1000.0
color = Gf.Vec3f(71.0 / 255.0, 165.0 / 255.0, 1.0)
orientation = Gf.Quatf(1.0, 0.0, 0.0, 0.0)
linVelocity = Gf.Vec3f(0.0)
angularVelocity = Gf.Vec3f(0.0)

for i in range(numActors):
    position = Gf.Vec3f(50.0, 50.0, 500.0 + i * 100.0)
    cubePath = boxActorsPath + "/boxActor" + str(i)

    add_rigid_box(
        stage,
        cubePath,
        Gf.Vec3f(size, size, size),
        position,
        orientation,
        color,
        density,
        linVelocity,
        angularVelocity,
    )

    add_collision_to_collision_group(stage, cubePath, cubesGroup)

# spheres/groupSpheres
sphereActorsPath = "/sphereActors"
UsdGeom.Xform.Define(stage, sphereActorsPath)

radius = 25.0
color = Gf.Vec3f(71.0 / 255.0, 125.0 / 255.0, 1.0)

for i in range(numActors):
    position = Gf.Vec3f(-50.0, -50.0, 500.0 + i * 100.0)
    spherePath = sphereActorsPath + "/sphereActor" + str(i)

    add_rigid_sphere(
        stage, spherePath, radius, position, orientation, color, density, linVelocity, angularVelocity
    )

    add_collision_to_collision_group(stage, spherePath, spheresGroup)

Pair Filtering

UsdPhysicsFilteredPairsAPI is used to disable collisions between individual objects like collision, body and articulation. The API is added to the object and in filteredPairs rel objects that this object should not collide against are defined.

This code is meant to follow the stage and scene creation in the first tutorial, it won’t work without that state being set up first.

from omni.physx.scripts.physicsUtils import *
from pxr import Usd, UsdGeom, Sdf, Gf, Tf, UsdPhysics

# Box0
boxActorPath = "/boxActor0"

density = 1000.0
size = Gf.Vec3f(25.0)
position = Gf.Vec3f(0.0, 0.0, 500.0)
orientation = Gf.Quatf(1.0, 0.0, 0.0, 0.0)
color = Gf.Vec3f(71.0 / 255.0, 165.0 / 255.0, 1.0)
linVelocity = Gf.Vec3f(2.0, 1.0, 2.0)
angularVelocity = Gf.Vec3f(1.0, 0.0, 0.0)

add_rigid_box(stage, boxActorPath, size, position, orientation, color, density, linVelocity, angularVelocity)

# Box1
boxActorPath = "/boxActor1"
position = Gf.Vec3f(0.0, 0.0, 250.0)
add_rigid_box(stage, boxActorPath, size, position, orientation, color, density, linVelocity, angularVelocity)

# filter collisions between Box0, Box1
boxPrim = stage.GetPrimAtPath("/boxActor0")
filteringPairsAPI = UsdPhysics.FilteredPairsAPI.Apply(boxPrim)
rel = filteringPairsAPI.CreateFilteredPairsRel()
rel.AddTarget("/boxActor1")

Contact Reports

Contact reports can be received in Python code by adding a PhysxContactReportAPI to the body or articulation Prim.

Subscribing to the contact event report, contacts are send through a callback function in two arrays.

The contact report first array contains contact headers, which can have type:

* ContactEventType.CONTACT_FOUND
* ContactEventType.CONTACT_PERSISTS
* ContactEventType.CONTACT_LOST

These events send the additional dictionary with contact information:

* actor0 - Usd path to rigid body actor 0 decoded into two ints. PhysicsSchemaTools.encodeSdfPath will return SdfPath.
* actor1 - Usd path to rigid body actor 1 decoded into two ints. PhysicsSchemaTools.encodeSdfPath will return SdfPath.
* collider0 - Usd path to collider 0 decoded into two ints. PhysicsSchemaTools.encodeSdfPath will return SdfPath.
* collider1 - Usd path to collider 1 decoded into two ints. PhysicsSchemaTools.encodeSdfPath will return SdfPath.
* stage_id - Stage that the report is coming from.
* contact_data_offset - Offset to the contact data array.
* num_contact_data - Number of contacts in the contact data array for this header.

The actual contact data are in the second array. Contact data contains this information:

* position - Contact position.
* normal - Contact normal.
* impulse - Contact impulse.
* separation - Separation value for collisions.
* face_index0 - Face index of the collider0 (filled only if available 0xFFFFFFFF otherwise).
* face_index1 - Face index of the collider1 (filled only if available 0xFFFFFFFF otherwise).
* material0 - Material of collider0.
* material1 - Material of collider1.

The following code will not execute and is just kept here as a guidance. Instead of copy pasting the snippet code please have a look at the Physics Demo Sample - contactReportDemo.

from omni.physx.scripts.physicsUtils import *
from pxr import Usd, UsdGeom, Sdf, Gf, Tf, Vt, UsdPhysics, PhysxSchema
from omni.physx._physx import SimulationEvent
from omni.physx import get_physx_interface


# acquire the physx interface
self._physx = _physx.acquire_physx_interface()

# subscribe to physics contact report event, this callback issued after each simulation step
self._contact_report_sub = get_physx_simulation_interface().subscribe_contact_report_events(self._on_contact_report_event)

# Spheres
spherePath = "/sphere"

radius = 30.0
position = Gf.Vec3f(0.0, 0.0, 800.0)
orientation = Gf.Quatf(1.0)
color = Gf.Vec3f(71.0 / 255.0, 165.0 / 255.0, 1.0)
density = 1000.0
linvel = Gf.Vec3f(0.0)

add_rigid_sphere(stage, spherePath, radius, position, orientation, color, density, linvel, Gf.Vec3f(0.0))

# apply contact report
spherePrim = stage.GetPrimAtPath(spherePath)
contactReportAPI = PhysxSchema.PhysxContactReportAPI.Apply(spherePrim)
contactReportAPI.CreatePhysxContactReportThresholdAttr().Set(200000)

def _on_contact_report_event(self, contact_headers, contact_data):
    for contact_header in contact_headers:
        print("Got contact header type: " + str(contact_header.type))
        print("Actor0: " + str(PhysicsSchemaTools.intToSdfPath(contact_header.actor0)))
        print("Actor1: " + str(PhysicsSchemaTools.intToSdfPath(contact_header.actor1)))
        print("Collider0: " + str(PhysicsSchemaTools.intToSdfPath(contact_header.collider0)))
        print("Collider1: " + str(PhysicsSchemaTools.intToSdfPath(contact_header.collider1)))
        print("StageId: " + str(contact_header.stage_id))
        print("Number of contacts: " + str(contact_header.num_contact_data))

        contact_data_offset = contact_header.contact_data_offset
        num_contact_data = contact_header.num_contact_data

        for index in range(contact_data_offset, contact_data_offset + num_contact_data, 1):
            print("Contact:")
            print("Contact position: " + str(contact_data[index].position))
            print("Contact normal: " + str(contact_data[index].normal))
            print("Contact impulse: " + str(contact_data[index].impulse))
            print("Contact separation: " + str(contact_data[index].separation))
            print("Contact faceIndex0: " + str(contact_data[index].face_index0))
            print("Contact faceIndex1: " + str(contact_data[index].face_index1))
            print("Contact material0: " + str(PhysicsSchemaTools.intToSdfPath(contact_data[index].material0)))
            print("Contact material1: " + str(PhysicsSchemaTools.intToSdfPath(contact_data[index].material1)))

Multiple Physics Scenes

Physics simulation does support multiple Physics Scenes. By default the first PhysicsScene found during traversal is used for the simulation. However it is possible to specify where individual actors should be simulated. RigidBodyAPI and CollisionAPI do have simulationOwner relationship that defines the owner of the rigid body. This defines where the body is simulated. Note that objects in physics scenes do not collide between each other.

Dynamic Rigid Bodies

Dynamic rigid bodies can have multiple owners (PhysicsScene), however only one can own it. The first rel defines the scene where the body is simulated as a dynamic body. It is then mirrored to the other scenes as a kinematic body.

Static Rigid Bodies

Static rigid bodies can have multiple owners (PhysicsScene), the same static body is mirrored to all the scenes that are defined in the simulationOwner rel.

Scene Queries

Scene queries allow you to gather information about the current scene state by using the same computations and data as what is used for simulating collisions. For the same reason, they only work during simulation.

In general they function by determining which colliders in the scene intersects or overlaps with the input shape, and come in three overall variants: Overlap, Raycast, and Sweep. Each type then exist in a number of subvariants that return a single result or multiple results.

Overlap

Overlap scene queries are the most forward types and will tell you whether and what colliders overlap with the input geometry. There are unique function variants for box, sphere, shape (UsdGeom.GPrim) and mesh (UsdGeom.Mesh).

Each of these come in subvariants that exclusively report whether any collider overlap at all (the “any”) and with subvariants that provide detailed information on each detected overlap. For the latter, this is handled by passing an input callback function, in which you can process the information for each individual detected overlap (supplied as a OverlapHit object). With the callback function, you can also control whether to continue or stop the query at the specific overlap by setting the function return value.

Example code:

from omni.physx import get_physx_scene_query_interface

body_prim_found = False
body_prim_path = "/World/BodyPrim"

def report_overlap(overlap):
    if overlap.rigid_body == prim_path:
        global prim_found
        prim_found = True
        # Now that we have found our prim, return False to abort further search.
        return False
    return True

origin = carb.Float3(0.0, 0.0, 50.0)
extent = carb.Float3(100.0, 100.0, 100.0)
rotation = carb.Float4(0.0, 0.0, 0.0, 1.0)

get_physx_scene_query_interface().overlap_box(extent, origin, rotation, report_overlap, False)
if prim_found:
    print("Prim overlapped box!")

The OverlapHit object has the following attributes:

collision - Path string to the collider that overlapped.

collision_encoded - Encoded SdfPath to the collider that overlapped. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

rigid_body - Path string to the rigid body that overlapped.

rigid_body_encoded - Encoded SdfPath to the rigid body that overlapped. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

protoIndex - ProtoIndex, filled for pointInstancers; otherwise, 0xFFFFFFFF.

Raycast

Raycast scene queries allow you to detect any colliders that intersect with the input ray. In addition to providing the same information as the Overlap queries, it also provides detailed data on the exact points of intersection.

Example code:

from omni.physx import get_physx_scene_query_interface

body_prim_found = False
body_prim_path = "/World/BodyPrim"
hit_position = carb.Float3(0.0, 0.0, 0.0)

def report_raycast(hit):
    if hit.rigid_body == body_prim_path:
        global body_prim_found
        body_prim_found = True
        global hit_position
        hit_position = hit.position
        # Now that we have found our prim, return False to abort further search.
        return False
    return True

origin = carb.Float3(0.0, 1000.0, 0.0)
direction = carb.Float3(0.0, -1.0, 0.0)
distance = 1000.0
rotation = carb.Float4(0.0, 0.0, 0.0, 1.0)

get_physx_scene_query_interface().raycast_all(origin, direction, distance, report_raycast)
if body_prim_found:
    print(f"Body prim was hit by ray at {hit_position}!")

The RaycastHit object has the following attributes:

collision - Path string to the collider that was hit.

collision_encoded - Encoded SdfPath to the collider that was hit. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

rigid_body - Path string to the rigid body that was hit.

rigid_body_encoded - Encoded SdfPath to the rigid body that was hit. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

protoIndex - ProtoIndex, filled for pointInstancers; otherwise, 0xFFFFFFFF.

distance - Hit location distance.

face_index - Hit location face index.

material - Path string to the collider material that was hit.

material_encoded - Encoded SdfPath to the collider material that was hit. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

normal - Hit location normal.

position - Hit location position.

Raycasting also features a subvariant that only returns information about the closest intersection in the form of a dictionary. Here is an example of using this variant:

Example code:

from omni.physx import get_physx_scene_query_interface

origin = carb.Float3(0.0, 1000.0, 0.0)
direction = carb.Float3(0.0, -1.0, 0.0)
distance = 1000.0
rotation = carb.Float4(0.0, 0.0, 0.0, 1.0)

hit_info = get_physx_scene_query_interface().raycast_closest(origin, direction, distance)
if hit_info['hit']:
    print(f"{hit_info['rigidBody']} was hit by ray at {hit_info['position']}!")

The returned dictionary includes the following data (notice the minor variations from RaycastHit objects):

hit - True if a hit was found, otherwise False.

collision - Path string to the collider that was hit.

rigidBody - Path string to the rigid body that was hit.

protoIndex - ProtoIndex, filled for pointInstancers; otherwise, 0xFFFFFFFF.

distance - Hit location distance.

faceIndex - Hit location face index.

material - Path string to the collider material that was hit.

normal - Hit location normal.

position - Hit location position.

Sweep

Sweep is almost identical to raycast, except that rather than just doing an intersection check against a line, you input an additional sphere radius for the check. The sweep scene query will then return intersection information corresponding to if you moved (or swept) a sphere along the direction you input.

Example code:

from omni.physx import get_physx_scene_query_interface

body_prim_found = False
body_prim_path = "/World/BodyPrim"
hit_position = carb.Float3(0.0, 0.0, 0.0)

def report_sweep(hit):
    if hit.rigid_body == body_prim_path:
        global body_prim_found
        body_prim_found = True
        global hit_position
        hit_position = hit.position
        # Now that we have found our prim, return False to abort further search.
        return False
    return True

radius = 100.0
origin = carb.Float3(0.0, 1000.0, 0.0)
direction = carb.Float3(0.0, -1.0, 0.0)
distance = 1000.0
rotation = carb.Float4(0.0, 0.0, 0.0, 1.0)

get_physx_scene_query_interface().sweep_sphere_all(radius, origin, direction, distance, report_sweep)
if body_prim_found:
    print(f"Body was hit by sweep at {hit_position}!")

The return values of the sweep scene queries are identical to those of the corresponding Raycast queries.

Python Bindings API

This module contains python bindings to the C++ omni::physx interface. Omni::physx contains several interfaces:

PhysX -- Main interface used for physics simulation.
PhysXVisualization -- Interface for debug visualization control.
PhysXUnitTests -- Interface for unit tests.

class omni.physx.bindings._physx.ContactData

Contact data.

property face_index0: Face index 0 - non zero only for meshes

property face_index1: Face index 1 - non zero only for meshes.

property impulse: Contact impulse

property material0: Material0 - uint64 use PhysicsSchemaTools::intToSdfPath to convert to SdfPath.

property material1: Material1 - uint64 use PhysicsSchemaTools::intToSdfPath to convert to SdfPath.

property normal: Contact normal.

property position: Contact position.

property separation: Contact separation value.

class omni.physx.bindings._physx.ContactDataVector

append(self: omni.physx.bindings._physx.ContactDataVector, x: omni.physx.bindings._physx.ContactData) → None: Add an item to the end of the list

clear(self: omni.physx.bindings._physx.ContactDataVector) → None: Clear the contents

extend(*args, **kwargs)

Overloaded function.

extend(self: omni.physx.bindings._physx.ContactDataVector, L: omni.physx.bindings._physx.ContactDataVector) -> None

Extend the list by appending all the items in the given list

extend(self: omni.physx.bindings._physx.ContactDataVector, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: omni.physx.bindings._physx.ContactDataVector, i: int, x: omni.physx.bindings._physx.ContactData) → None: Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

pop(self: omni.physx.bindings._physx.ContactDataVector) -> omni.physx.bindings._physx.ContactData

Remove and return the last item

pop(self: omni.physx.bindings._physx.ContactDataVector, i: int) -> omni.physx.bindings._physx.ContactData

Remove and return the item at index i

class omni.physx.bindings._physx.ContactEventHeader

Contact event header.

property actor0: Actor0 - uint64 use PhysicsSchemaTools::intToSdfPath to convert to SdfPath.

property actor1: Actor1 - uint64 use PhysicsSchemaTools::intToSdfPath to convert to SdfPath.

property collider0: Collider0 - uint64 use PhysicsSchemaTools::intToSdfPath to convert to SdfPath.

property collider1: Collider1 - uint64 use PhysicsSchemaTools::intToSdfPath to convert to SdfPath.

property contact_data_offset: Contact data offset.

property friction_anchors_offset: Friction anchors data offset.

property num_contact_data: Number of contact data.

property num_friction_anchors_data: Number of contact data.

property proto_index0: Protoindex0 from a point instancer (0xFFFFFFFF means collider is not part of an instancer).

property proto_index1: Protoindex1 from a point instancer (0xFFFFFFFF means collider is not part of an instancer).

property stage_id: Stage id.

property type: Contact event type.

class omni.physx.bindings._physx.ContactEventHeaderVector

append(self: omni.physx.bindings._physx.ContactEventHeaderVector, x: omni.physx.bindings._physx.ContactEventHeader) → None: Add an item to the end of the list

clear(self: omni.physx.bindings._physx.ContactEventHeaderVector) → None: Clear the contents

extend(*args, **kwargs)

Overloaded function.

extend(self: omni.physx.bindings._physx.ContactEventHeaderVector, L: omni.physx.bindings._physx.ContactEventHeaderVector) -> None

Extend the list by appending all the items in the given list

extend(self: omni.physx.bindings._physx.ContactEventHeaderVector, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: omni.physx.bindings._physx.ContactEventHeaderVector, i: int, x: omni.physx.bindings._physx.ContactEventHeader) → None: Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

pop(self: omni.physx.bindings._physx.ContactEventHeaderVector) -> omni.physx.bindings._physx.ContactEventHeader

Remove and return the last item

pop(self: omni.physx.bindings._physx.ContactEventHeaderVector, i: int) -> omni.physx.bindings._physx.ContactEventHeader

Remove and return the item at index i

class omni.physx.bindings._physx.ContactEventType

Contact event type.

Members:

CONTACT_FOUND : Contact found.

CONTACT_LOST : Contact lost.

CONTACT_PERSIST : Contact persist.

CONTACT_FOUND = <ContactEventType.CONTACT_FOUND: 0>

CONTACT_LOST = <ContactEventType.CONTACT_LOST: 1>

CONTACT_PERSIST = <ContactEventType.CONTACT_PERSIST: 2>

property name

property value

class omni.physx.bindings._physx.ErrorEvent

Error events used by physics error event stream.

Members:

USD_LOAD_ERROR : Usd load error, event has dictionary with key ‘errorString’:string

PHYSX_ERROR : PhysX runtime error, event has dictionary with key ‘errorString’:string

PHYSX_TOO_MANY_ERRORS : PhysX exceeded maximum number of reported errors, event has dictionary with key ‘errorString’:string

PHYSX_CUDA_ERROR : PhysX GPU Cuda error, event has dictionary with key ‘errorString’:string

PHYSX_CUDA_ERROR = <ErrorEvent.PHYSX_CUDA_ERROR: 2>

PHYSX_ERROR = <ErrorEvent.PHYSX_ERROR: 1>

PHYSX_TOO_MANY_ERRORS = <ErrorEvent.PHYSX_TOO_MANY_ERRORS: 3>

USD_LOAD_ERROR = <ErrorEvent.USD_LOAD_ERROR: 0>

property name

property value

class omni.physx.bindings._physx.FrictionAnchor

Contact data.

property impulse: Contact impulse

property position: Contact position.

class omni.physx.bindings._physx.FrictionAnchorsDataVector

append(self: omni.physx.bindings._physx.FrictionAnchorsDataVector, x: omni.physx.bindings._physx.FrictionAnchor) → None: Add an item to the end of the list

clear(self: omni.physx.bindings._physx.FrictionAnchorsDataVector) → None: Clear the contents

extend(*args, **kwargs)

Overloaded function.

extend(self: omni.physx.bindings._physx.FrictionAnchorsDataVector, L: omni.physx.bindings._physx.FrictionAnchorsDataVector) -> None

Extend the list by appending all the items in the given list

extend(self: omni.physx.bindings._physx.FrictionAnchorsDataVector, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: omni.physx.bindings._physx.FrictionAnchorsDataVector, i: int, x: omni.physx.bindings._physx.FrictionAnchor) → None: Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

pop(self: omni.physx.bindings._physx.FrictionAnchorsDataVector) -> omni.physx.bindings._physx.FrictionAnchor

Remove and return the last item

pop(self: omni.physx.bindings._physx.FrictionAnchorsDataVector, i: int) -> omni.physx.bindings._physx.FrictionAnchor

Remove and return the item at index i

class omni.physx.bindings._physx.IPhysxAttachment

This interface is the access point to the omni.physx attachment functionality.

add_surface_sampler_points(self: omni.physx.bindings._physx.IPhysxAttachment, surface_sampler: int, points: List[carb::Float3]) → None

Add samples to surface sampler.

Parameters

surface_sampler – Handle to surface sampler
points – Points to add

This function adds samples to the surface sampler that are then considered for further sampling.

compute_attachment_points(self: omni.physx.bindings._physx.IPhysxAttachment, attachment_path: str) → bool

Compute attachment points

Parameters: attachment_path – path to PhysxSchema.PhysxPhysicsAttachment primitive with PhysxSchema.PhysxAutoAttachmentAPI

create_point_finder(self: omni.physx.bindings._physx.IPhysxAttachment, points: List[carb::Float3]) → int

Create point finder.

Parameters: points – Points of the mesh
Returns: Handle to point finder

create_surface_sampler(self: omni.physx.bindings._physx.IPhysxAttachment, collider_path: str, sampling_distance: float) → int

Create surface Poisson sampler.

Parameters

collider_path – Path to prim with UsdPhysics.CollisionAPI
sampling_distance – Distance used for sampling points

Returns

Handle to surface sampler

create_tet_finder(self: omni.physx.bindings._physx.IPhysxAttachment, points: List[carb::Float3], indices: List[int]) → int

Create tet finder.

Parameters

points – Points of the tetrahedral mesh
indices – Indices of the tetrahedral mesh

Returns

Handle to tet finder

create_tri_mesh_sampler(self: omni.physx.bindings._physx.IPhysxAttachment, surface_sampler: int) → None

Get closest points to the input points on the prim

Parameters

points – input points
path – prim path

Returns

Return a dictionary with closest information:

'closest_points': float3 - Closest points to the input points on the prim. Only valid when returned distance is strictly positive.
'dists': float - Square distances between the points and the geom object. 0.0 if the point is inside the object.

get_closest_points(self: omni.physx.bindings._physx.IPhysxAttachment, point: List[carb::Float3], path: str) → dict

Get closest points to the input points on the prim

Parameters

points – input points
path – prim path

Returns

Return a dictionary with closest information:

'closest_points': float3 - Closest points to the input points on the prim. Only valid when returned distance is strictly positive.
'dists': float - Square distances between the points and the geom object. 0.0 if the point is inside the object.

get_surface_sampler_points(self: omni.physx.bindings._physx.IPhysxAttachment, surface_sampler: int) → dict

Get the samples of surface sampler.

Parameters: surface_sampler – Handle to surface sampler
Returns: Dict mapping ‘points’ to the resulting sampling points

is_point_inside(self: omni.physx.bindings._physx.IPhysxAttachment, surface_sampler: int, point: carb::Float3) → bool

Get closest points to the input points on the prim

Parameters

points – input points
path – prim path

Returns

Return a dictionary with closest information:

'closest_points': float3 - Closest points to the input points on the prim. Only valid when returned distance is strictly positive.
'dists': float - Square distances between the points and the geom object. 0.0 if the point is inside the object.

overlap_tetmesh_capsule(self: omni.physx.bindings._physx.IPhysxAttachment, tet_finder: int, pos: carb::Float3, axis: carb::Float3, radius: float, half_height: float) → dict

Finds all tetrahedra overlapping with a capsule.

Parameters

tet_finder – Handle to tet finder
pos – Position of capsule
axis – Orientation of the capsule
radius – Radius of the capsule
capsule (half_height Half height of the) –

Returns

Dict mapping ‘tet_ids’ to the resulting indices of tetrahedra overlapping with the capsule.

overlap_tetmesh_sphere(self: omni.physx.bindings._physx.IPhysxAttachment, tet_finder: int, center: carb::Float3, radius: float) → dict

Finds all tetrahedra overlapping with a sphere.

Parameters

tet_finder – Handle to tet finder
center – Center of sphere
radius – Radius of sphere

Returns

Dict mapping ‘tet_ids’ to the resulting indices of tetrahedra overlapping with the sphere.

points_to_indices(self: omni.physx.bindings._physx.IPhysxAttachment, point_finder: int, points: List[carb::Float3]) → dict

Map points to indices.

Parameters

point_finder – Handle to point finder
points – Points to be mapped

Returns

Dict mapping ‘indices’ to the resulting mesh coordinates. Indices might be -1 for points outside of the mesh.

points_to_tetmesh_local(self: omni.physx.bindings._physx.IPhysxAttachment, tet_finder: int, points: List[carb::Float3]) → dict

Map points in euclidean coordiantes to tet mesh coordinates.

Parameters

tet_finder – Handle to tet finder
points – Points to be mapped

Returns

Dict mapping ‘tet_ids’ and ‘barycentric_coords’ to the resulting local tet mesh coordinates. Tet indices might be -1 for points outside of the tetrahedral mesh.

release_point_finder(self: omni.physx.bindings._physx.IPhysxAttachment, point_finder: int) → None

Release point finder.

Parameters: point_finder – Handle to point finder

release_surface_sampler(self: omni.physx.bindings._physx.IPhysxAttachment, surface_sampler: int) → None

Release surface Poisson sampler.

Parameters: surface_sampler – Handle to surface sampler

release_tet_finder(self: omni.physx.bindings._physx.IPhysxAttachment, tet_finder: int) → None

Release tet finder.

Parameters: tet_finder – Handle to tet finder

remove_surface_sampler_points(self: omni.physx.bindings._physx.IPhysxAttachment, surface_sampler: int, points: List[carb::Float3]) → None

Remove samples from surface sampler.

Parameters

surface_sampler – Handle to surface sampler
points – Points to remove

This function removes samples from the surface sampler.

sample_surface(self: omni.physx.bindings._physx.IPhysxAttachment, surface_sampler: int, sphere_center: carb::Float3, sphere_radius: float, sampling_distance: float) → dict

Create new surface samples within specified sphere.

Parameters

surface_sampler – Handle to surface sampler
sphere_center – Center of sphere used for restricting sampling domain
sphere_radius – Radius of sphere used for restricting sampling domain

Returns

Dict mapping ‘points’ to the resulting sampling points

New samples are created on the surface for which the samples has been created, and within the sphere specified.

tetmesh_local_to_points(self: omni.physx.bindings._physx.IPhysxAttachment, tet_finder: int, tet_ids: List[int], barycentric_coords: List[carb::Float4]) → dict

Map tet mesh coordinates to points in euclidean coordinates.

Parameters

tet_finder – Handle to tet finder
tet_ids – Tetrahedra indices
barycentric_coords – Barycentric coordinates

Returns

Dict mapping ‘points’ to the resulting points in euclidean coordinates.

class omni.physx.bindings._physx.IPhysxBenchmarks

This interface is the access point to the omni.physx benchmarks.

enable_profile(self: omni.physx.bindings._physx.IPhysxBenchmarks, enable_profile: bool) → None: Enabled profiling :param enable_profile: Do custom physics profiling

get_profile_stats(self: omni.physx.bindings._physx.IPhysxBenchmarks) → dict: Get profiling stats

class omni.physx.bindings._physx.IPhysxPropertyQuery

query_prim(self: omni.physx.bindings._physx.IPhysxPropertyQuery, stage_id: int, prim_id: int, query_mode: omni.physx.bindings._physx.PhysxPropertyQueryMode = <PhysxPropertyQueryMode.QUERY_RIGID_BODY_WITH_COLLIDERS: 0>, timeout_ms: int = -1, finished_fn: Callable[[], None] = None, rigid_body_fn: Callable[[omni.physx.bindings._physx.PhysxPropertyQueryRigidBodyResponse], None] = None, collider_fn: Callable[[omni.physx.bindings._physx.PhysxPropertyQueryColliderResponse], None] = None) → None

Returns information for given prim

Parameters

stage_id – uint64_t Stage id
prim_id – uint64_t USD path (use PhysicsSchemaTools::sdfPathToInt)
query_mode – PhysxPropertyQueryMode Type of query to be made
timeout_ms – int64 Timeout (in milliseconds) for the request. (-1 means wait forever)
finished_fn – function Report function called when enumeration of all objects is finished
rigid_body_fn – function Report function where rigid body information will be returned in PhysxPropertyQueryRigidBodyResponse object
collider_fn – function Report function where collider information will be returned in PhysxPropertyQueryRigidBodyResponse object

class omni.physx.bindings._physx.IPhysxReplicator

register_replicator(self: omni.physx.bindings._physx.IPhysxReplicator, stage_id: int, replicator_attach_fn: Callable[[int], list], replicator_attach_end_fn: Callable[[int], None], hierarchy_rename_fn: Callable[[str, int], str]) → None

Register replicator for given stage.

stage_id: current stageId

replicator_attach_fn: std::function<py::list(uint64_t stageId)>;

replicator_attach_end_fn: std::function<py::list(uint64_t stageId)>;

hierarchy_rename_fn: std::function<const char* (const char* replicatePath, uint32_t index)>;

replicate(self: omni.physx.bindings._physx.IPhysxReplicator, stage_id: int, path: str, numReplications: int) → bool

Replicate hierarchy.

stage_id: stage id path: path to replicate numReplications: number of replications

unregister_replicator(self: omni.physx.bindings._physx.IPhysxReplicator, stage_id: int) → None: Unregister replicator from stage.

class omni.physx.bindings._physx.IPhysxSimulation

This interface is the access point to the omni.physx simulation control.

apply_force_at_pos(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int, force: carb::Float3, pos: carb::Float3, mode: str = 'Force') → None

Applies force at given body with given force position.

Parameters

stage_id – USD stageId
body_path – USD path of the body encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt
force – Force to apply to the body.
pos – World position where the force is applied.
mode – Supporting various modes - Force (default), Impulse, Velocity, Acceleration.

apply_force_at_pos_instanced(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, point_instancer_path: int, force: carb::Float3, pos: carb::Float3, mode: str = 'Force', proto_index: int = 4294967295) → None

Applies force at given point instancer body with given force position.

Parameters

stage_id – USD stageId
point_instancer_path – USD path to a point instancer encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt
force – Force to apply to the target.
pos – World position where the force is applied.
mode – Supporting various modes - Force (default), Impulse, Velocity, Acceleration.
protoIndex – If protoIndex is 0xffffffff (default), force will be applied to all instances, otherwise it will only be applied to the instance at this index.

apply_torque(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int, torque: carb::Float3) → None

Applies torque at given body at body center of mass.

Parameters

stage_id – USD stageId
body_path – USD path of the body encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt
torque – Torque to apply to the body.

apply_torque_instanced(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int, torque: carb::Float3, proto_index: int = 4294967295) → None

Applies torque at given point instancer body at body center of mass.

Parameters

stage_id – USD stageId
point_instancer_path – USD path to a point instancer encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt
torque – Torque to apply to the body.
protoIndex – If protoIndex is 0xffffffff (default), torque will be applied to all instances, otherwise it will only be applied to the instance at this index.

attach_stage(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int) → bool

Attach USD stage. This will run the physics parser and will populate the PhysX SDK with the corresponding simulation objects.

Note: previous stage will be detached.

Parameters: stage_id – USD stageId (can be retrieved from a stagePtr - UsdUtils.StageCache.Get().GetId(stage).ToLongInt())
Returns: Returns true if stage was successfully attached.

check_results(self: omni.physx.bindings._physx.IPhysxSimulation) → bool

Check if simulation finished.

Returns: Returns true if simulation has finished.

check_results_scene(self: omni.physx.bindings._physx.IPhysxSimulation, scene_path: int) → bool

Check if a simulation scene is finished. Disabling a scene has no effect on this function. If scenePath is empty, it behaves like IPhysxSimulation::checkResults

Returns True if the simulation scene is finished.

scenePath uint64_t Scene USD path use PhysicsSchemaTools::sdfPathToInt

detach_stage(self: omni.physx.bindings._physx.IPhysxSimulation) → None: Detach USD stage, this will remove all objects from the PhysX SDK

fetch_results(self: omni.physx.bindings._physx.IPhysxSimulation) → None

Fetch simulation results. Writing out simulation results based on physics settings.

Note This is a blocking call. The function will wait until the simulation is finished.

fetch_results_scene(self: omni.physx.bindings._physx.IPhysxSimulation, scene_path: int) → None

Fetch simulation scene results and writes out simulation results based on physics settings for a specific scene. Disabling a scene has no effect on this function. If scenePath is empty, it behaves like IPhysxSimulation::fetchResults

Note: this is a blocking call. The function will wait until the simulation scene is finished.

scenePath uint64_t Scene USD path use PhysicsSchemaTools::sdfPathToInt

flush_changes(self: omni.physx.bindings._physx.IPhysxSimulation) → None

Flush changes will force physics to process buffered changes

Changes to physics gets buffered, in some cases flushing changes is required if order is required.

Example - prim A gets added. Existing prim B has a relationship that gets switched to use A. Currently, the relationship change gets processed immediately and fails because prim A only gets added at the start of the next sim step.

get_attached_stage(self: omni.physx.bindings._physx.IPhysxSimulation) → int

Returns the currently attached stage through the IPhysxSimulation interface

Returns: Returns USD stage id.

get_contact_report(self: omni.physx.bindings._physx.IPhysxSimulation) → tuple

Get contact report data for current simulation step directly.

The contact buffer data are available for one simulation step

Returns

Tuple with contact event vector and contact data vector:

'contact_headers': vector of contact event headers
'contact_data': vector of contact data
'friction_anchors': vector of friction anchors data

get_full_contact_report(self: omni.physx.bindings._physx.IPhysxSimulation) → tuple

Get contact report data for current simulation step directly, including friction anchors.

The contact buffer data are available for one simulation step

Returns

Tuple with contact event vector and contact data vector:

'contact_headers': vector of contact event headers
'contact_data': vector of contact data
'friction_anchors': vector of friction anchors data

is_change_tracking_paused(self: omni.physx.bindings._physx.IPhysxSimulation) → bool

Check if fabric change tracking for physics listener is paused or not

Returns true if paused change tracking.

is_sleeping(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int) → bool

Is body sleeping.

Parameters

stage_id – USD stageId
body_path – USD path of the body encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt

Returns

True if body is asleeep

is_sleeping_instanced(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int, proto_index: int) → bool

Is point instancer bodypoint instancer body sleeping.

Parameters

stage_id – USD stageId
point_instancer_path – USD path to a point instancer encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt
protoIndex – Check against the instance at this index.

Returns

True if body is asleeep

pause_change_tracking(self: omni.physx.bindings._physx.IPhysxSimulation, pause: bool) → None

Pause fabric change tracking for physics listener.

Parameters: tracking. (pause bool Pause or unpause change) –

put_to_sleep(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int) → None

Put body to sleep.

Parameters

stage_id – USD stageId
body_path – USD path of the body encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt

put_to_sleep_instanced(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int, proto_index: int = 4294967295) → None

Put point instancer body to sleep.

Parameters

stage_id – USD stageId
point_instancer_path – USD path to a point instancer encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt
protoIndex – If protoIndex is 0xffffffff (default), all instances will be put to sleep, otherwise it will only be applied to the instance at this index.

simulate(self: omni.physx.bindings._physx.IPhysxSimulation, elapsed_time: float, current_time: float) → None

Execute physics asynchronous simulation.

Parameters

elapsed_time – Simulation time (seconds).
current_time – Current time (seconds), might be used for time sampled transformations to apply.

simulate_scene(self: omni.physx.bindings._physx.IPhysxSimulation, scene_path: int, elapsed_time: float, current_time: float) → None

Execute the physics simulation on a specific scene.

The PhysX simulation in the scene will simulate the exact elapsedTime passed. No substepping will happen. It is the caller’s responsibility to provide a reasonable elapsedTime. In general it is recommended to use fixed size time steps with a maximum of 1/60 of a second. If scenePath is empty, it behaves like IPhysxSimulation::simulate

scenePath uint64_t Scene USD path use PhysicsSchemaTools::sdfPathToInt elapsedTime float Simulation time (seconds). currentTime float Current time (seconds), might be used for time sampled transformations to apply.

subscribe_contact_report_events(self: omni.physx.bindings._physx.IPhysxSimulation, fn: Callable[[omni.physx.bindings._physx.ContactEventHeaderVector, omni.physx.bindings._physx.ContactDataVector], None]) → carb::Subscription

Subscribes to contact report callback function.

The contact buffer data are available for one simulation step

Parameters: fn – The callback to be called after simulation step to receive contact reports.
Returns: The subscription holder.

subscribe_full_contact_report_events(self: omni.physx.bindings._physx.IPhysxSimulation, fn: Callable[[omni.physx.bindings._physx.ContactEventHeaderVector, omni.physx.bindings._physx.ContactDataVector, omni.physx.bindings._physx.FrictionAnchorsDataVector], None]) → carb::Subscription

Subscribes to contact report callback function including friction anchors.

The contact buffer data are available for one simulation step

Parameters: fn – The callback to be called after simulation step to receive contact reports.
Returns: The subscription holder.

subscribe_physics_trigger_report_events(self: omni.physx.bindings._physx.IPhysxSimulation, trigger_report_fn: Callable[[omni.physx.bindings._physx.TriggerEventData], None], stage_id: int = 0, prim_id: int = 0) → int

Register for trigger notifications

Parameters

trigger_report_fn – function Report function where enter or leave trigger events will be notified
stage_id – uint64_t [Optional] Stage id to filter triggers from
prim_id – uint64_t [Optional] USD path to filter triggers from (use PhysicsSchemaTools::sdfPathToInt)

Returns

SubscriptionId Subscription Id that can be unregistered with unsubscribe_physics_trigger_report_events

Return type

subscription_id

unsubscribe_physics_trigger_report_events(self: omni.physx.bindings._physx.IPhysxSimulation, subscriptionId: int) → None

Unregister a subscription for trigger notifications

Parameters: subscription_id – SubscriptionId Subscription Id

wake_up(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int) → None

Wake up body.

Parameters

stage_id – USD stageId
body_path – USD path of the body encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt

wake_up_instanced(self: omni.physx.bindings._physx.IPhysxSimulation, stage_id: int, body_path: int, proto_index: int = 4294967295) → None

Wake up point instancer body.

Parameters

stage_id – USD stageId
point_instancer_path – USD path to a point instancer encoded in uint64_t use PhysicsSchemaTools::sdfPathToInt
protoIndex – If protoIndex is 0xffffffff (default), all instances will be awakened, otherwise it will only be applied to the instance at this index.

class omni.physx.bindings._physx.IPhysxStageUpdate

on_attach(self: omni.physx.bindings._physx.IPhysxStageUpdate, arg0: int) → None

Called when a stage gets attached, does not load physics. Does just set internally stage.

stage_id: current stageId

on_detach(self: omni.physx.bindings._physx.IPhysxStageUpdate) → None: Called when stage gets detached.

on_fabric_attach(self: omni.physx.bindings._physx.IPhysxStageUpdate, arg0: int) → None

Called again when a stage gets attached, but at a later point, where fabric stage is already created.

stage_id: current stageId

on_pause(self: omni.physx.bindings._physx.IPhysxStageUpdate) → None: Called when timeline gets paused.

on_reset(self: omni.physx.bindings._physx.IPhysxStageUpdate) → None: Called when timeline is stopped.

on_resume(self: omni.physx.bindings._physx.IPhysxStageUpdate, arg0: float) → None

Called when timeline play is requested.

current_time: Current time in seconds

on_update(self: omni.physx.bindings._physx.IPhysxStageUpdate, arg0: float, arg1: float, arg2: bool) → None

Called when on stage update.

current_time: Current time in seconds elapsed_sec: Elapsed time from previous update in seconds enable_update: Enable physics update, physics can be disabled, but we still need to update other subsystems

class omni.physx.bindings._physx.IPhysxStatistics

get_physx_scene_statistics(self: omni.physx.bindings._physx.IPhysxStatistics, arg0: int, arg1: int, arg2: omni.physx.bindings._physx.PhysicsSceneStats) → bool

Get physics scene PhysX simulation statistics.

stage_id: current stageId path: physics scene path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.

class omni.physx.bindings._physx.OverlapHit: Sweep hit results structure.

class omni.physx.bindings._physx.ParticleVisualizationPositionType

Particle position debug visualiztion option for smoothed fluid particles for use with SETTING_DISPLAY_PARTICLES_POSITION_TYPE.

SIM_POSITIONS = 0

SMOOTHED_POSITIONS = 1

class omni.physx.bindings._physx.ParticleVisualizationRadiusType

Particle radius debug visualization option for use with SETTING_DISPLAY_PARTICLES_RADIUS_TYPE.

ANISOTROPY = 4

CONTACT_OFFSET = 0

PARTICLE_CONTACT_OFFSET = 2

PARTICLE_REST_OFFSET = 3

RENDER_GEOMETRY = 5

REST_OFFSET = 1

class omni.physx.bindings._physx.PhysX

This interface is the main access point to omni.physx extension. It contains functions that can control the simulation, modify the simulation or work directly with physics objects.

apply_force_at_pos(self: omni.physx.bindings._physx.PhysX, body_path: str, force: carb::Float3, pos: carb::Float3, mode: str = 'Force') → None

Applies force at given body with given force position.

Deprecated, please use apply_force_at_pos at physx_simulation_interface

Parameters

body_path – USD path of the body.
force – Force to apply to the body.
pos – World position where the force is applied.
mode – Supporting various modes - Force (default), Impulse, Velocity, Acceleration.

cancel_collision_tasks(self: omni.physx.bindings._physx.PhysX) → int: Returns the number of active collision cooking tasks which were canceled

check_backwards_compatibility(self: omni.physx.bindings._physx.PhysX, stage_id: int = - 1) → bool: Checks for occurrences of any old schema format.

compute_vehicle_velocity(self: omni.physx.bindings._physx.PhysX, path: str, direction: carb::Float3) → float

Get the linear velocity of a vehicle (vehicle prim needs to have vehicle API applied).

Note

Should only be called after the simulation has been started.

Parameters

path – Vehicle USD path.
direction – carb.Float3: Unit length direction vector along which the linear velocity should get computed. The vector is considered to be relative to the center of mass frame of the vehicle. If None is passed in, then the local forward direction of the vehicle will be used.

Returns

The velocity along the provided direction vector.

force_load_physics_from_usd(self: omni.physx.bindings._physx.PhysX) → None: Forces load physics objects from USD into PhysX. By default physics is not loaded; this function forces a load of all physics from USD into PhysX.

get_backwards_compatibility_check_log(self: omni.physx.bindings._physx.PhysX) → str: Get backwards compatibility check log. Valid for last run of backward compatibility check.

get_error_event_stream(self: omni.physx.bindings._physx.PhysX) → carb::events::IEventStream

Error event stream sending various error events defined in ErrorEvent enum.

Returns: Event stream sending the physics errors.

get_num_collision_tasks(self: omni.physx.bindings._physx.PhysX) → int: Returns the number of active collision cooking tasks

get_overwrite_gpu_setting(self: omni.physx.bindings._physx.PhysX) → int

Get CPU vs GPU simulation settings.

Returns: -1 - use setting from schema, 0 - force CPU, 1 - force GPU
Return type: Integer defining the behavior

get_rigidbody_transformation(self: omni.physx.bindings._physx.PhysX, path: str) → dict

Gets rigid body current transformation in a global space.

Parameters

path – The USD path to the rigid body.

Returns

Return a dictionary with transformation info:

'ret_val': bool - whether transformation was found
'position': float3 - rigid body position
'rotation': float4 - rigid body rotation (quat - x,y,z,w)

get_simulation_event_stream_v2(self: omni.physx.bindings._physx.PhysX) → carb::events::IEventStream

Simulation event stream sending various simulation events defined in SimulationEvent enum.

Returns: Event stream sending the simulation events.

get_vehicle_drive_state(self: omni.physx.bindings._physx.PhysX, path: str) → dict

Get the drive state of a vehicle.

Note

Should only be called after the simulation has been started.

Parameters

path – Vehicle USD path.

Returns

A dictionary with the following key, value pairs. An empty dictionary is returned for an invalid path, when the simulation is not running or when the vehicle does not have a Basic or Standard drive type.

VEHICLE_DRIVE_STATE_ACCELERATOR, d (in range [0, 1]),
VEHICLE_DRIVE_STATE_BRAKE0, d (in range [0, 1]),
VEHICLE_DRIVE_STATE_BRAKE1, d (in range [0, 1]),
VEHICLE_DRIVE_STATE_STEER, d (in range [-1, 1]),
VEHICLE_DRIVE_STATE_CLUTCH, d (in range [0, 1], only applicable to PhysxVehicleDriveStandard drive type),
VEHICLE_DRIVE_STATE_CURRENT_GEAR, i (only applicable to PhysxVehicleDriveStandard drive type),
VEHICLE_DRIVE_STATE_TARGET_GEAR, i (only applicable to PhysxVehicleDriveStandard drive type),
VEHICLE_DRIVE_STATE_GEAR_SWITCH_TIME, d (in seconds, negative value if no gear shift is in process. Only applicable to PhysxVehicleDriveStandard drive type),
VEHICLE_DRIVE_STATE_AUTOBOX_TIME_SINCE_LAST_SHIFT, d (in seconds, only applicable toPhysxVehicleDriveStandard drive type),
VEHICLE_DRIVE_STATE_ENGINE_ROTATION_SPEED, d (in radians per second, only applicable to PhysxVehicleDriveStandard drive type),
VEHICLE_DRIVE_STATE_AUTOMATIC_TRANSMISSION, i (only applicable to PhysxVehicleDriveStandard drive type)

get_wheel_state(self: omni.physx.bindings._physx.PhysX, path: str) → dict

Get the wheel state.

Note

Should only be called after the simulation has been started.

Parameters

path – Wheel attachment USD path.

Returns

A dictionary with the following key, value pairs. An empty dictionary is returned for an invalid path.

VEHICLE_WHEEL_STATE_LOCAL_POSE_POSITION, (d, d, d),
VEHICLE_WHEEL_STATE_LOCAL_POSE_QUATERNION, (d, d, d, d)
VEHICLE_WHEEL_STATE_ROTATION_SPEED, d (in radians per second),
VEHICLE_WHEEL_STATE_ROTATION_ANGLE, d (in radians),
VEHICLE_WHEEL_STATE_STEER_ANGLE, d (in radians),
VEHICLE_WHEEL_STATE_GROUND_PLANE, (d, d, d, d) (first 3 entries are plane normal n, fourth entry is d of equation dot(n, v) + d = 0). Only valid if wheel is on ground, see VEHICLE_WHEEL_STATE_IS_ON_GROUND,
VEHICLE_WHEEL_STATE_GROUND_ACTOR, string (USD path of the actor prim the wheel is driving on). Only valid if wheel is on ground, see VEHICLE_WHEEL_STATE_IS_ON_GROUND,
VEHICLE_WHEEL_STATE_GROUND_SHAPE, string (USD path of the collider prim the wheel is driving on). Only valid if wheel is on ground, see VEHICLE_WHEEL_STATE_IS_ON_GROUND,
VEHICLE_WHEEL_STATE_GROUND_MATERIAL, string (USD path of the material prim the wheel is driving on). Only valid if wheel is on ground, see VEHICLE_WHEEL_STATE_IS_ON_GROUND,
VEHICLE_WHEEL_STATE_GROUND_HIT_POSITION, (d, d, d) (hit position on the ground in world space). Only valid if wheel is on ground, see VEHICLE_WHEEL_STATE_IS_ON_GROUND,
VEHICLE_WHEEL_STATE_SUSPENSION_JOUNCE, d,
VEHICLE_WHEEL_STATE_SUSPENSION_FORCE, (d, d, d),
VEHICLE_WHEEL_STATE_TIRE_FRICTION, d,
VEHICLE_WHEEL_STATE_TIRE_LONGITUDINAL_DIRECTION, (d, d, d),
VEHICLE_WHEEL_STATE_TIRE_LATERAL_DIRECTION, (d, d, d),
VEHICLE_WHEEL_STATE_TIRE_LONGITUDINAL_SLIP, d,
VEHICLE_WHEEL_STATE_TIRE_LATERAL_SLIP, d,
VEHICLE_WHEEL_STATE_TIRE_FORCE, (d, d, d),
VEHICLE_WHEEL_STATE_IS_ON_GROUND, i, whether the wheel did touch the ground or is in air (=0). If the vehicle is disabled or sleeping then the wheel will be treated as not touching ground too.

is_asyncsimrender_enabled(self: omni.physx.bindings._physx.PhysX) → bool: Returns true if asynchronous simulation and rendering is enabled for one of the scenes in the simulation.

is_interactive_actor_raycast(self: omni.physx.bindings._physx.PhysX, arg0: carb::Float3, arg1: carb::Float3) → bool

Raycast check to detect interactive physics actors

Note

Only produces positive results during simulation

Parameters

origin – carb.Float3: World-space origin of raycast
direction – carb.Float3: Unit-length direction vector of raycast

Returns

True if interactive actor is hit; False otherwise, or if simulation is not running

is_readback_suppressed(self: omni.physx.bindings._physx.PhysX) → bool

Check if GPU readback is suppressed for currently running simulation.

Returns: True if simulation is running with suppressed readback. Always returns false when simulation is not running.

is_running(self: omni.physx.bindings._physx.PhysX) → bool: Check if simulation loop is running, this function returns true if play was pressed or if IPhysxSimulation was attached.

overwrite_gpu_setting(self: omni.physx.bindings._physx.PhysX, gpuSetting: int) → None

Override CPU vs GPU simulation settings.

Parameters: gpuSetting – Integer defining the behavior: -1 - use setting from schema, 0 - force CPU, 1 - force GPU

overwrite_solver_type(self: omni.physx.bindings._physx.PhysX, solverSetting: int) → None

Override PhysX solver settings.

Parameters: solverSetting – Integer defining the behavior: -1 - use setting from schema, 0 - force PGS, 1 - force TGS

put_to_sleep(self: omni.physx.bindings._physx.PhysX, body_path: str) → None

Put body to sleep.

Deprecated, please use apply_force_at_pos at physx_simulation_interface

Parameters: body_path – USD path of the body.

reconnect_pvd(self: omni.physx.bindings._physx.PhysX) → None: Reconnect to PVD (PhysX Visual Debugger)

release_local_mesh_cache(self: omni.physx.bindings._physx.PhysX) → None: Release Local Mesh Cache.

release_physics_objects(self: omni.physx.bindings._physx.PhysX) → None: Forces release of all physics objects from PhysX.

reset_setting(self: omni.physx.bindings._physx.PhysX, arg0: str) → None: Resets all physics settings to their default values.

reset_settings(self: omni.physx.bindings._physx.PhysX) → None: Resets all physics settings to their default values.

reset_settings_in_preferences(self: omni.physx.bindings._physx.PhysX) → None: Resets physics preferences to their default values.

reset_settings_in_stage(self: omni.physx.bindings._physx.PhysX) → None: Resets physics per-stage settings to their default values.

reset_simulation(self: omni.physx.bindings._physx.PhysX) → None: Reset physics simulation and set back original transformations stored during start_simulation. This will also remove all data from PhysX.

run_backwards_compatibility(self: omni.physx.bindings._physx.PhysX, stage_id: int = - 1) → None: Runs the backwards compatibility code, will try to fix older schema format to a new format.

save_scene_to_repx(self: omni.physx.bindings._physx.PhysX, arg0: str) → bool: Save scene to RepX, if scene is not loaded, load scene, save and release.

set_simulation_layer(self: omni.physx.bindings._physx.PhysX, layer: str) → None

Sets simulation layer. This layer is used when simulation output transformations are written to USD.

Parameters: layer – The layer that we simulate to.

set_thread_count(self: omni.physx.bindings._physx.PhysX, numThreads: int) → None

Sets number of threads for simulation.

Parameters: numThreads – Number of threads that physics should use

set_vehicle_to_rest_state(self: omni.physx.bindings._physx.PhysX, path: str) → None

Set the internal dynamics state of a vehicle back to the rest state.

Note

Should only be called after the simulation has been started.

Parameters: path – Vehicle USD path.

set_voxel_range(self: omni.physx.bindings._physx.PhysX, stage_id: int, path: str, sx: int, sy: int, sz: int, ex: int, ey: int, ez: int, type: int, subtype: int, update: int) → bool

Set Voxelmap Voxels

Parameters

stage_id – Stage containing source mesh primitive.
input_path – path to input primitive
sx – voxel range start X
sy – voxel range start Y
sz – voxel range start Z
ex – voxel range end X
ey – voxel range end Y
ez – voxel range end Z
type – voxel type
sub_type – voxel subtype
update – update flag, if zero, writing changes to USD is postponed, if non-zero, all accumulated changes are written to USD

set_wheel_rotation_angle(self: omni.physx.bindings._physx.PhysX, path: str, rotationAngle: float) → None

Set the rotation angle about the rolling axis of a wheel.

Note

Should only be called after the simulation has been started.

Parameters

path – Wheel attachment USD path.
rotationAngle – Rotation angle of the wheel in radians.

set_wheel_rotation_speed(self: omni.physx.bindings._physx.PhysX, path: str, rotationSpeed: float) → None

Set the rotation speed about the rolling axis of a wheel.

Note

Should only be called after the simulation has been started.

Parameters

path – Wheel attachment USD path.
rotationSpeed – Rotation speed of the wheel in radians per second.

start_simulation(self: omni.physx.bindings._physx.PhysX) → None: Start simulation, store initial USD data. Call this before manually stepping simulation.

subscribe_object_changed_notifications(self: omni.physx.bindings._physx.PhysX, object_creation_fn: Callable[[int, int, int], None] = None, object_destruction_fn: Callable[[int, int, int], None] = None, all_objects_destruction_fn: Callable[[], None] = None, stop_callback_when_sim_stopped: bool = True) → int

Subscribes to Object Changed Notifications

Parameters

object_creation_fn – function(path, object_id, physx_type) Notification when a physics object gets created during simulation.
object_destruction_fn – function(path, object_id, physx_type) Notification when a physics object gets destroyed during simulation.
all_objects_destruction_fn – function Notification when all physics objects get destroyed during simulation.
stopCallbackWhenSimStopped – bool Whether these callbacks should not be sent when the simulation stops

Returns

The subscription holder (SubscriptionId) to use with unsubscribe_object_change_notifications

subscribe_physics_on_step_events(self: omni.physx.bindings._physx.PhysX, fn: Callable[[float], None], pre_step: bool, order: int) → carb::Subscription

Subscribes to physics pre-step or post-step events.

Subscription cannot be changed in the onUpdate callback

Parameters

fn – The callback to be called right before or after every physics step.
pre_step – Whether fn has to be called right before the physics step. If this is false, it will be called right after the physics step.
order – An integer value used to order the callbacks: 0 means “highest priority”, 1 is “less priority” and so on.

Returns

The subscription holder.

subscribe_physics_step_events(self: omni.physx.bindings._physx.PhysX, fn: Callable[[float], None]) → carb::Subscription

Subscribes to physics step events.

Subscription cannot be changed in the onUpdate callback

Parameters: fn – The callback to be called on every physics step.
Returns: The subscription holder.

unsubscribe_object_change_notifications(self: omni.physx.bindings._physx.PhysX, subscription_id: int) → None: Unsubscribes object change notifications with the subscriptionID as returned by subscribe_object_changed_notifications

update_interaction(self: omni.physx.bindings._physx.PhysX, arg0: carb::Float3, arg1: carb::Float3, arg2: omni.physx.bindings._physx.PhysicsInteractionEvent) → None

Updates actor interaction based on user input and raycast origin and direction

Note

Only provides interaction during simulation

Parameters

origin – carb.Float3: World-space origin of interaction
direction – carb.Float3: Unit-length direction vector of interaction
event – PhysicsInteractionEvent triggered.

update_simulation(self: omni.physx.bindings._physx.PhysX, elapsedStep: float, currentTime: float) → None

Update physics simulation by one step.

Parameters

elapsedStep – Simulation step time (seconds), time elapsed between last step and this step.
currentTime – Current time (seconds), might be used for time sampled transformations to apply.

update_simulation_scene(self: omni.physx.bindings._physx.PhysX, scene_path: int, elapsed_step: float, current_time: float) → None

Update and step a specific scene in the physics simulation. The specific scene specified in scenePath is updated and stepped even if marked as ‘Disabled’. If scenePath is empty, it behaves like IPhysx::updateSimulation

Parameters

scenePath – uint64_t Scene USD path use PhysicsSchemaTools::sdfPathToInt
elapsedStep – float Simulation time (seconds).
currentTime – float Current time (seconds), might be used for time sampled transformations to apply.

update_transformations(self: omni.physx.bindings._physx.PhysX, updateToFastCache: bool, updateToUsd: bool, updateVelocitiesToUsd: bool = False, outputVelocitiesLocalSpace: bool = False) → None

Update transformations after simulation is done.

Parameters

updateToFastCache – Update transformation in fast cache.
updateToUsd – Update transformations in USD.
updateVelocitiesToUsd – Update velocities in USD.

update_transformations_scene(self: omni.physx.bindings._physx.PhysX, scene_path: int, update_to_usd: bool, update_velocities_to_usd: bool) → None

Update the transformations for a specific scene in the physics simulation. The specific scene specified in scenePath has its transformations updated even if it is marked as ‘Disabled’. If scenePath is empty, it behaves like IPhysx::updateTransformations

scenePath uint64_t Scene USD path use PhysicsSchemaTools::sdfPathToInt updateToUsd bool Update transforms to USD. updateVelocitiesToUsd bool Update velocities to USD.

wake_up(self: omni.physx.bindings._physx.PhysX, body_path: str) → None

Wake up body.

Deprecated, please use apply_force_at_pos at physx_simulation_interface

Parameters: body_path – USD path of the body.

class omni.physx.bindings._physx.PhysXCooking

This interface is the access point to the omni.physx extension cooking API.

add_prim_to_cooking_refresh_set(self: omni.physx.bindings._physx.PhysXCooking, arg0: pxrInternal_v0_22__pxrReserved__::SdfPath) → None

Adds Prim to cooking refresh set.

Parameters: primPath – path to Prim

cancel_collision_representation_task(self: omni.physx.bindings._physx.PhysXCooking, task: omni.physx.bindings._physx.PhysxCollisionRepresentationTask, invoke_callback: bool = True) → None

Cancels an async physics collision representation task made with request_convex_collision_representation

Parameters

task – PhysxCollisionRepresentationTask The task returned by request_convex_collision_representation to cancel
invoke_callback – bool If the on_result callback should be invoked anyway

cancel_collision_tasks(self: omni.physx.bindings._physx.PhysXCooking) → int: Returns the number of active collision cooking tasks which were canceled

compute_conforming_tetrahedral_mesh(self: omni.physx.bindings._physx.PhysXCooking, src_tri_points: List[carb::Float3], src_tri_indices: List[int]) → dict

Create a conforming tetrahedral mesh from a closed source triangle mesh.

Parameters

mesh (src_tri_points Vertices of the source triangle) –
triangles (src_tri_indices Vertex indices of the source) –

Returns

Dict mapping ‘points’ and ‘indices’ to the resulting tetrahedral mesh points and indices

The conforming tetrahedral mesh is defined as a tetrahedral mesh whose surface triangles align with the closed source triangle mesh and whose internal vertices lie on the inside of the closed source triangle mesh.

compute_edge_length_limited_triangle_mesh(self: omni.physx.bindings._physx.PhysXCooking, arg0: List[carb::Float3], arg1: List[int], arg2: float) → dict: Limits the maximum edge length in a triangle mesh

compute_voxel_tetrahedral_mesh(self: omni.physx.bindings._physx.PhysXCooking, src_tet_points: List[carb::Float3], src_tet_indices: List[int], src_scale: carb::Float3, voxel_resolution: int) → dict

Create a voxel tetrahedral mesh from a source tetrahedral mesh.

Parameters

src_tet_points – Vertices of teh source tetrahedral mesh
src_tet_indices – Vertex indices of the source tetrahedral mesh
src_scale – Scale of source mesh used to determine resolution of the resulting voxel mesh
voxel_resolution – Number of voxels along longest dimension of axis aligned bounding box of source mesh

Returns

Dict mapping ‘points’ and ‘indices’ to the resulting tetrahedral mesh points and indices

The voxel tetrahedral mesh is made by voxelizing the source tetrahedra on a regular grid. The resulting voxel tetrahedral mesh embeds all tetrahedra of the source mesh. The provided voxel resolution may be lowered automatically in order to match a lower resolution detected in the source mesh. This may help to avoid softbody convergence issues with high-resolution tetrahedra embedding low resolution collision meshes.

cook_deformable_body_mesh(self: omni.physx.bindings._physx.PhysXCooking, deformable_body_path: str) → bool

Cooks deformable body mesh

Parameters

stage_id – Stage containing source mesh primitive.
deformable_body_path – path to UsdGeomMesh with PhysxSchemaPhysxDeformableBodyAPI

get_convex_mesh_data(self: omni.physx.bindings._physx.PhysXCooking, meshPath: str, convexIndex: int) → dict

Get convex mesh data for given prim path. (Does work only when simulation is running.)

Returns

Return a dictionary with convex mesh:

'num_vertices': int - number of vertices
'num_polygons': int - number of polygons
'vertices': list - vertices list
'polygons': list - list of dictionaries, dictionary with polygon data::
    'plane' : float4 - Plane format: (mPlane[0],mPlane[1],mPlane[2]).dot(x) + mPlane[3] = 0
    'num_vertices' : int - number of vertices for the current polygon
    'index_base' : int - base index to the indices array
'indices': list - list of indices

get_nb_convex_mesh_data(self: omni.physx.bindings._physx.PhysXCooking, meshPath: str) → int: Get number of convex mesh data for given prim path. (Does work only when simulation is running.)

get_num_collision_tasks(self: omni.physx.bindings._physx.PhysXCooking) → int: Returns the number of active collision cooking tasks

poisson_sample_mesh(self: omni.physx.bindings._physx.PhysXCooking, mesh_path: str, async: bool) → bool

Samples particle positions from mesh

Parameters: mesh_path – path to UsdGeomMesh with PhysxParticleSamplingAPI

release_local_mesh_cache(self: omni.physx.bindings._physx.PhysXCooking) → None: Release Local Mesh Cache.

request_convex_collision_representation(self: omni.physx.bindings._physx.PhysXCooking, stage_id: int, collision_prim_id: int, run_asynchronously: bool = True, on_result: Callable[[omni.physx.bindings._physx.PhysxCollisionRepresentationResult, List[omni.physx.bindings._physx.PhysxConvexMeshData]], None]) → omni.physx.bindings._physx.PhysxCollisionRepresentationTask

Request physics collision representation of an USD mesh

Parameters

stage_id – uint64_t Stage where prim exists
collision_prim_id – uint64_t Prim Id of the prim with CollisionAPI
run_asynchronously – bool If the request should be run asynchronously
on_result – Callable[PhysxCollisionRepresentationResult, list[PhysxConvexMeshData]) The callback with the wanted collision representation. result: Value of type PhysxCollisionRepresentationResult convexes: list of PhysxConvexMeshData

Returns: A PhysxCollisionRepresentationTask that can be cancelled with cancel_collision_representation_task: (if async request has been made)

wait_for_cooking_to_finish(self: omni.physx.bindings._physx.PhysXCooking) → None: Waits for all cooking tasks to finish.

class omni.physx.bindings._physx.PhysXSceneQuery

This interface is the access point to the omni.physx extension scene query API.

overlap_box(self: omni.physx.bindings._physx.PhysXSceneQuery, halfExtent: carb::Float3, pos: carb::Float3, rot: carb::Float4, reportFn: Callable[[omni.physx.bindings._physx.OverlapHit], bool], anyHit: bool = False) → int

Overlap test of a box against objects in the physics scene.

Parameters

halfExtent – Box half extent.
pos – Origin of the box overlap (barycenter of the box).
rot – Rotation of the box overlap (quat x, y, z, w)
reportFn – Report function where SceneQueryHits will be reported, return True to continue traversal, False to stop traversal
anyHit – Boolean defining whether overlap should report only bool hit (0 no hit, 1 hit found).

Returns

Return number of hits founds

overlap_box_any(self: omni.physx.bindings._physx.PhysXSceneQuery, halfExtent: carb::Float3, pos: carb::Float3, rot: carb::Float4) → bool

Overlap test of a box against objects in the physics scene, reports only boolean

Parameters

extent – Box extent.
pos – Origin of the box overlap.
rot – Rotation of the box overlap (quat x, y, z, w)

Returns

Returns True if overlap found

overlap_mesh(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, reportFn: Callable[[omni.physx.bindings._physx.OverlapHit], bool], anyHit: bool = False) → int

Overlap test of a UsdGeom.Mesh against objects in the physics scene. Overlap test will use convex mesh approximation of the input mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

mesh – UsdGeom.Mesh path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
reportFn – Report function where SceneQueryHits will be reported, return True to continue traversal, False to stop traversal
anyHit – Boolean defining whether overlap should report only bool hit (0 no hit, 1 hit found).

Returns

Return number of hits founds

overlap_mesh_any(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int) → bool

Overlap test of a UsdGeom.Mesh against objects in the physics scene. Overlap test will use convex mesh approximation of the input mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow. Reports only boolean.

Parameters: mesh – UsdGeom.Mesh path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
Returns: Returns True if overlap was found.

overlap_shape(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, reportFn: Callable[[omni.physx.bindings._physx.OverlapHit], bool], anyHit: bool = False) → int

Overlap test of a UsdGeom.GPrim against objects in the physics scene. Overlap test will use convex mesh approximation if the input is a mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

gprim – UsdGeom.GPrim path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
reportFn – Report function where SceneQueryHits will be reported, return True to continue traversal, False to stop traversal
anyHit – Boolean defining whether overlap should report only bool hit (0 no hit, 1 hit found).

Returns

Return number of hits founds

overlap_shape_any(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int) → bool

Overlap test of a UsdGeom.GPrim against objects in the physics scene. Overlap test will use convex mesh approximation if the input is a mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow. Reports only boolean.

Parameters: gprim – UsdGeom.GPrim path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
Returns: Returns True if overlap was found.

overlap_sphere(self: omni.physx.bindings._physx.PhysXSceneQuery, radius: float, pos: carb::Float3, reportFn: Callable[[omni.physx.bindings._physx.OverlapHit], bool], anyHit: bool = False) → int

Overlap test of a sphere against objects in the physics scene.

Parameters

radius – Sphere radius.
pos – Origin of the sphere overlap.
reportFn – Report function where SceneQueryHits will be reported, return True to continue traversal, False to stop traversal
anyHit – Boolean defining whether overlap should report only bool hit (0 no hit, 1 hit found).

Returns

Return number of hits founds

overlap_sphere_any(self: omni.physx.bindings._physx.PhysXSceneQuery, radius: float, pos: carb::Float3) → bool

Overlap test of a sphere against objects in the physics scene, reports only boolean.

Parameters

radius – Sphere radius.
pos – Origin of the sphere overlap.

Returns

Returns True if overlap found.

raycast_all(self: omni.physx.bindings._physx.PhysXSceneQuery, origin: carb::Float3, dir: carb::Float3, distance: float, reportFn: Callable[[omni.physx.bindings._physx.RaycastHit], bool], bothSides: bool = False) → bool

Raycast physics scene for all collisions.

Parameters

origin – Origin of the raycast.
dir – Unit direction of the raycast.
distance – Raycast distance.
reportFn – Report function where RaycastHits will be reported, return True to continue traversal, False to stop traversal
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Returns true if hit

raycast_any(self: omni.physx.bindings._physx.PhysXSceneQuery, origin: carb::Float3, dir: carb::Float3, distance: float, bothSides: bool = False) → bool

Raycast physics scene for any collision, reporting only boolean.

Parameters

origin – Origin of the raycast.
dir – Unit direction of the raycast.
distance – Raycast distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Return a boolean whether raycast hit.

raycast_closest(self: omni.physx.bindings._physx.PhysXSceneQuery, origin: carb::Float3, dir: carb::Float3, distance: float, bothSides: bool = False) → dict

Raycast physics scene for the closest collision.

Parameters

origin – Origin of the raycast.
dir – Unit direction of the raycast.
distance – Raycast distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Return a dictionary with raycast hit:

'position': float3 -- Hit position.
'normal': float3 -- Hit normal.
'distance': float -- Hit distance.
'faceIndex': int -- Hit mesh face index.
'collision': string -- Hit collision USD path.
'rigidBody': string -- Hit rigid body USD path.
'protoIndex': int -- Rigid body protoIndex - if not point instancer 0xFFFFFFFF
'material': string -- Hit collider material USD path.

sweep_box_all(self: omni.physx.bindings._physx.PhysXSceneQuery, halfExtent: carb::Float3, pos: carb::Float3, rot: carb::Float4, dir: carb::Float3, distance: float, reportFn: Callable[[omni.physx.bindings._physx.SweepHit], bool], bothSides: bool = False) → bool

Box sweep physics scene for all collisions.

Parameters

halfExtent – Box half extent.
pos – Origin of the sweep (barycenter of the box).
rot – Rotation of the box (quat x, y, z, w)
dir – Unit direction of the sweep.
distance – sweep distance.
reportFn – Report function where SweepHits will be reported, return True to continue traversal, False to stop traversal
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Returns true if hit

sweep_box_any(self: omni.physx.bindings._physx.PhysXSceneQuery, halfExtent: carb::Float3, pos: carb::Float3, rot: carb::Float4, dir: carb::Float3, distance: float, bothSides: bool = False) → bool

Box sweep physics scene for any collision, reporting only boolean.

Parameters

halfExtent – Box half extent.
pos – Origin of the sweep (barycenter of the box).
rot – Rotation of the sweep box (quat x, y, z, w)
dir – Unit direction of the sweep.
distance – sweep distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Return a boolean if sweep hit.

sweep_box_closest(self: omni.physx.bindings._physx.PhysXSceneQuery, halfExtent: carb::Float3, pos: carb::Float3, rot: carb::Float4, dir: carb::Float3, distance: float, bothSides: bool = False) → dict

Box sweep physics scene for the closest collision.

Parameters

halfExtent – Box half extent.
pos – Origin of the sweep (barycenter of the box).
rot – Rotation of the sweep box (quat x, y, z, w)
dir – Unit direction of the sweep.
distance – sweep distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Return a dictionary with raycast hit:

'position': float3 - hit position
'normal': float3 - hit normal
'distance': float - hit distance
'faceIndex': int - hit mesh face index
'collision': string - hit collision USD path
'rigidBody': string - hit rigid body USD path
'protoIndex': int -- Rigid body protoIndex - if not point instancer 0xFFFFFFFF
'material': string -- Hit collider material USD path.

sweep_mesh_all(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, dir: carb::Float3, distance: float, reportFn: Callable[[omni.physx.bindings._physx.SweepHit], bool], bothSides: bool = False) → bool

Sweep test of a UsdGeom.Mesh against objects in the physics scene. Sweep test will use convex mesh approximation of the input mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

mesh – UsdGeom.Mesh path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
dir – Unit direction of the sweep.
distance – sweep distance.
reportFn – Report function where SweepHits will be reported, return True to continue traversal, False to stop traversal
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Returns true if hit

sweep_mesh_any(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, dir: carb::Float3, distance: float, bothSides: bool = False) → bool

Sweep test of a UsdGeom.Mesh against objects in the physics scene for any collision, reporting only boolean. Sweep test will use convex mesh approximation of the input mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

mesh – UsdGeom.Mesh path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
dir – Unit direction of the sweep.
distance – sweep distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Return a boolean if sweep hit.

sweep_mesh_closest(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, dir: carb::Float3, distance: float, bothSides: bool = False) → dict

Sweep test of a UsdGeom.Mesh against objects in the physics scene for the closest collision. Sweep test will use convex mesh approximation of the input mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

mesh – UsdGeom.Mesh path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
dir – Unit direction of the sweep.
distance – sweep distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

‘position’: float3 - hit position ‘normal’: float3 - hit normal ‘distance’: float - hit distance ‘faceIndex’: int - hit mesh face index ‘collision’: string - hit collision USD path ‘rigidBody’: string - hit rigid body USD path ‘protoIndex’: int – Rigid body protoIndex - if not point instancer 0xFFFFFFFF ‘material’: string – Hit collider material USD path.

Return type

Return a dictionary with sweep hit

sweep_shape_all(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, dir: carb::Float3, distance: float, reportFn: Callable[[omni.physx.bindings._physx.SweepHit], bool], bothSides: bool = False) → bool

Sweep test of a UsdGeom.GPrim against objects in the physics scene. Sweep test will use convex mesh approximation if the input is a mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

gprim – UsdGeom.GPrim path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
dir – Unit direction of the sweep.
distance – sweep distance.
reportFn – Report function where SweepHits will be reported, return True to continue traversal, False to stop traversal
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Returns true if hit

sweep_shape_any(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, dir: carb::Float3, distance: float, bothSides: bool = False) → bool

Sweep test of a UsdGeom.GPrim against objects in the physics scene for any collision, reporting only boolean. Sweep test will use convex mesh approximation if the input is a mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

gprim – UsdGeom.GPrim path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
dir – Unit direction of the sweep.
distance – sweep distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Return a boolean if sweep hit.

sweep_shape_closest(self: omni.physx.bindings._physx.PhysXSceneQuery, meshPath0: int, meshPath1: int, dir: carb::Float3, distance: float, bothSides: bool = False) → dict

Sweep test of a UsdGeom.GPrim against objects in the physics scene. Sweep test will use convex mesh approximation if the input is a mesh. The first query will need to cook this approximation so if the results are not stored in a local cache, this query might be slow.

Parameters

gprim – UsdGeom.GPrim path encoded into two integers. Use PhysicsSchemaTools.encodeSdfPath to get those.
dir – Unit direction of the sweep.
distance – sweep distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

‘position’: float3 - hit position ‘normal’: float3 - hit normal ‘distance’: float - hit distance ‘faceIndex’: int - hit mesh face index ‘collision’: string - hit collision USD path ‘rigidBody’: string - hit rigid body USD path ‘protoIndex’: int – Rigid body protoIndex - if not point instancer 0xFFFFFFFF ‘material’: string – Hit collider material USD path.

Return type

Return a dictionary with sweep hit

sweep_sphere_all(self: omni.physx.bindings._physx.PhysXSceneQuery, radius: float, origin: carb::Float3, dir: carb::Float3, distance: float, reportFn: Callable[[omni.physx.bindings._physx.SweepHit], bool], bothSides: bool = False) → bool

Sphere sweep physics scene for all collisions.

Parameters

radius – Sphere radius
origin – Origin of the sweep.
dir – Unit direction of the sweep.
distance – sweep distance.
reportFn – Report function where SweepHits will be reported, return True to continue traversal, False to stop traversal
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Returns true if hit

sweep_sphere_any(self: omni.physx.bindings._physx.PhysXSceneQuery, radius: float, origin: carb::Float3, dir: carb::Float3, distance: float, bothSides: bool = False) → bool

Sphere sweep physics scene for any collision, reporting only boolean.

Parameters

radius – Sphere radius.
origin – Origin of the sphere sweep.
dir – Unit direction of the sphere sweep.
distance – Sphere sweep distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

Return a boolean if sphere sweep hit.

sweep_sphere_closest(self: omni.physx.bindings._physx.PhysXSceneQuery, radius: float, origin: carb::Float3, dir: carb::Float3, distance: float, bothSides: bool = False) → dict

Sphere sweep physics scene for the closest collision.

Parameters

radius – Sphere radius.
origin – Origin of the sphere cast.
dir – Unit direction of the sphere cast.
distance – Sphere cast distance.
bothSides – Boolean defining whether front and back side of a mesh triangle should be considered for hits.

Returns

‘position’: float3 - hit position ‘normal’: float3 - hit normal ‘distance’: float - hit distance ‘faceIndex’: int - hit mesh face index ‘collision’: string - hit collision USD path ‘rigidBody’: string - hit rigid body USD path ‘protoIndex’: int – Rigid body protoIndex - if not point instancer 0xFFFFFFFF ‘material’: string – Hit collider material USD path.

Return type

Return a dictionary with sweep hit

class omni.physx.bindings._physx.PhysXUnitTests

This interface is the access point to omni.physx test support functions.

end_logger_check(self: omni.physx.bindings._physx.PhysXUnitTests) → bool

get_mass_information(self: omni.physx.bindings._physx.PhysXUnitTests, body_path: str) → dict

Returns mass information for a given body.

Parameters

body. (body_path - USD path to) –

Returns

Return a dictionary with mass information:

'mass': float - Mass of the body.
'inertia': float3 - Inertia tensor of body.
'com': float3 - Center of mass of the body.

get_materials_paths(self: omni.physx.bindings._physx.PhysXUnitTests, collider_path: str) → list

Returns material paths for materials found on given collider path.

Parameters: collider. (collider_path - USD path to a) –
Returns: Return a list of material paths

get_physics_stats(self: omni.physx.bindings._physx.PhysXUnitTests) → dict

Returns simulation statistics after a simulation step.

Returns

Return a dictionary with statistics:

'numDynamicRigids': int - Number of dynamic rigids in simulation.
'numStaticRigids': int - Number of static rigids in simulation.
'numKinematicBodies': int - Number of kinematic rigids in simulation.
'numArticulations': int - Number of articulations in simulation.
'numSphereShapes': int - Number of sphere shapes in simulation.
'numBoxShapes': int - Number of box shapes in simulation.
'numCapsuleShapes': int - Number of capsule shapes in simulation.
'numCylinderShapes': int - Number of cylinder shapes in simulation.
'numConvexShapes': int - Number of convex shapes in simulation.
'numTriMeshShapes': int - Number of triangle mesh shapes in simulation.
'numPlaneShapes': int - Number of plane shapes in simulation.
'numConeShapes': int - Number of cone shapes in simulation.

is_cuda_lib_present(self: omni.physx.bindings._physx.PhysXUnitTests) → bool

start_logger_check(self: omni.physx.bindings._physx.PhysXUnitTests, arg0: str, arg1: bool) → None

start_logger_check_for_multiple(self: omni.physx.bindings._physx.PhysXUnitTests, arg0: List[str], arg1: bool, arg2: bool) → None

update(self: omni.physx.bindings._physx.PhysXUnitTests, elapsedStep: float, currentTime: float) → None

Update physics simulation by one step.

Parameters

elapsedStep – Simulation step time (seconds), time elapsed between last step and this step.
currentTime – Current time (seconds), might be used for time sampled transformations to apply.

class omni.physx.bindings._physx.PhysXVisualization

This interface is the access point to PhysX SDK debug visualization.

enable_visualization(self: omni.physx.bindings._physx.PhysXVisualization, enable: bool) → None

Enable/disable PhysX debug visualization.

Parameters: disable. (enable - Bool if enable or) –

get_nb_lines(self: omni.physx.bindings._physx.PhysXVisualization) → int: Get number of PhysX debug visualization lines. This serves mostly as a test function.

set_visualization_parameter(self: omni.physx.bindings._physx.PhysXVisualization, debug_vis: str, enable: bool) → None

Toggle individual debug visualization features.

Parameters

identifier (debug_vis - Debug visualization feature string) – {‘WorldAxes’, ‘BodyAxes’, ‘BodyMassAxes’, ‘BodyLinearVel’, ‘BodyAngularVel’, ‘ContactPoint’, ‘ContactNormal’, ‘ContactError’, ‘ContactImpulse’, ‘FrictionPoint’, ‘FrictionNormal’, ‘FrictionImpulse’, ‘ActorAxes’, ‘CollisionAABBs’, ‘CollisionShapes’, ‘CollisionAxes’, ‘CollisionCompounds’, ‘CollisionEdges’, ‘CollisionStaticPruner’, ‘CollisionDynamicPruner’, ‘JointLocalFrames’, ‘JointLimits’, ‘CullBox’, ‘MBPRegions’}
following (can be one of the) – {‘WorldAxes’, ‘BodyAxes’, ‘BodyMassAxes’, ‘BodyLinearVel’, ‘BodyAngularVel’, ‘ContactPoint’, ‘ContactNormal’, ‘ContactError’, ‘ContactImpulse’, ‘FrictionPoint’, ‘FrictionNormal’, ‘FrictionImpulse’, ‘ActorAxes’, ‘CollisionAABBs’, ‘CollisionShapes’, ‘CollisionAxes’, ‘CollisionCompounds’, ‘CollisionEdges’, ‘CollisionStaticPruner’, ‘CollisionDynamicPruner’, ‘JointLocalFrames’, ‘JointLimits’, ‘CullBox’, ‘MBPRegions’}
feature. (enable - Bool to enable/disable the) –

set_visualization_scale(self: omni.physx.bindings._physx.PhysXVisualization, scale: float) → None

Set PhysX debug visualization scale.

Parameters: visualization. (scale - Float value for scaling debug) –

class omni.physx.bindings._physx.PhysicsInteractionEvent

Physics interaction event

Members:

MOUSE_DRAG_BEGAN : Signals that a mouse drag has begun.

MOUSE_DRAG_CHANGED : Signals that the mouse is being dragged.

MOUSE_DRAG_ENDED : Signals that the mouse drag is being released.

MOUSE_LEFT_CLICK : Signals that the mouse left button is clicked.

MOUSE_LEFT_DOUBLE_CLICK : Signals that the mouse left button is being double-clicked.

MOUSE_DRAG_BEGAN = <PhysicsInteractionEvent.MOUSE_DRAG_BEGAN: 0>

MOUSE_DRAG_CHANGED = <PhysicsInteractionEvent.MOUSE_DRAG_CHANGED: 1>

MOUSE_DRAG_ENDED = <PhysicsInteractionEvent.MOUSE_DRAG_ENDED: 2>

MOUSE_LEFT_CLICK = <PhysicsInteractionEvent.MOUSE_LEFT_CLICK: 3>

MOUSE_LEFT_DOUBLE_CLICK = <PhysicsInteractionEvent.MOUSE_LEFT_DOUBLE_CLICK: 4>

property name

property value

class omni.physx.bindings._physx.PhysicsSceneStats

Physics scene statistics.

property compressed_contact_size: The size (in bytes) of the compressed contact stream in the current simulation step.

property gpu_mem_collision_stack_size

gpuCollisionStackSize

Type: Actual GPU device memory (bytes) needed for the collision stack of Gpu Collision Stack Size set with physxScene

property gpu_mem_deformable_surface_contacts

gpuMaxDeformableSurfaceContacts

Type: Actual number of deformable surface contacts needed of Gpu Max Deformable Surface Contacts set with physxScene

property gpu_mem_fem_cloths: GPU device memory in bytes allocated for FEM-based cloth state accessible through API.

property gpu_mem_found_lost_aggregate_pairs

gpuFoundLostAggregatePairsCapacity

Type: Actual number of found/lost aggregate pairs needed of Gpu Found Lost Aggregate Pairs Capacity set with physxScene

property gpu_mem_found_lost_pairs

gpuFoundLostPairsCapacity

Type: Actual number of found/lost pairs needed of Gpu Found Lost Pairs Capacity set with physxScene

property gpu_mem_hair_systems: GPU device memory in bytes allocated for hairsystem state accessible through API.

property gpu_mem_heap

gpuHeapCapacity.

Type: GPU device memory in bytes allocated for internal heap allocation based on initial Gpu Heap Capacity set with physxScene

property gpu_mem_heap_articulation: GPU device heap memory used for articulations in bytes.

property gpu_mem_heap_broadphase: GPU device heap memory used for broad phase in bytes.

property gpu_mem_heap_fem_cloths: GPU device heap memory used for shared buffers in the FEM-based cloth pipeline in bytes.

property gpu_mem_heap_hair_systems: GPU device heap memory used for shared buffers in the hairsystem pipeline in bytes.

property gpu_mem_heap_narrowphase: GPU device heap memory used for narrow phase in bytes.

property gpu_mem_heap_other: GPU device heap memory not covered by other stats in bytes.

property gpu_mem_heap_particles: GPU device heap memory used for shared buffers in the particles pipeline in bytes.

property gpu_mem_heap_simulation: GPU device heap memory used for simulation pipeline in bytes.

property gpu_mem_heap_simulation_articulation: GPU device heap memory used for articulations in the simulation pipeline in bytes.

property gpu_mem_heap_simulation_fem_cloths: GPU device heap memory used for FEM-cloth in the simulation pipeline in bytes.

property gpu_mem_heap_simulation_hair_systems: GPU device heap memory used for hairsystem in the simulation pipeline in bytes.

property gpu_mem_heap_simulation_particles: GPU device heap memory used for particles in the simulation pipeline in bytes.

property gpu_mem_heap_simulation_softbody: GPU device heap memory used for soft bodies in the simulation pipeline in bytes.

property gpu_mem_heap_softbodies: GPU device heap memory used for shared buffers in the FEM-based soft body pipeline in bytes.

property gpu_mem_heap_solver: GPU device heap memory used for solver in bytes.

property gpu_mem_particle_contacts

gpuMaxParticleContacts

Type: Actual number of particle contacts needed of Gpu Max Particle Contact Count set with physxScene

property gpu_mem_particles: GPU device memory in bytes allocated for particle state accessible through API.

property gpu_mem_rigid_contact_count

gpuMaxRigidContactCount

Type: Actual number of rigid contacts needed of Gpu Max Rigid Contact Count set with physxScene

property gpu_mem_rigid_patch_count

gpuMaxRigidPatchCount

Type: Actual number of rigid contact patches needed of Gpu Max Rigid Patch Count set with physxScene

property gpu_mem_softbodies: GPU device memory in bytes allocated for FEM-based soft body state accessible through API.

property gpu_mem_softbody_contacts

gpuMaxSoftBodyContacts

Type: Actual number of soft body contacts needed of Gpu Max Softbody Contacts set with physxScene

property gpu_mem_temp_buffer_capacity

gpuTempBufferCapacity

Type: Actual GPU device memory (bytes) used for Temp Buffer based on initial Gpu Temp Buffer Capacity set with physxScene

property gpu_mem_total_aggregate_pairs

gpuTotalAggregatePairsCapacity

Type: Actual number of aggregate pairs needed of Gpu Total Aggregate Pairs Capacity set with physxScene

property nb_active_constraints: The number of active constraints.

property nb_active_dynamic_rigids: The number of active dynamic rigid bodies.

property nb_active_kinematic_rigids: The number of active kinematic rigid bodies.

property nb_aggregates: The number of aggregates.

property nb_articulations: The number of articulations.

property nb_axis_solver_constaints: The number of 1D axis constraints(joints+contact) present in the current simulation step.

property nb_box_shapes: The number of box shapes.

property nb_capsule_shapes: The number of capsule shapes.

property nb_cone_shapes: The number of cone shapes.

property nb_convex_shapes: The number of convex shapes.

property nb_cylinder_shapes: The number of cylinder shapes.

property nb_discrete_contact_pairs_total: Total number of (non CCD) pairs reaching narrow phase.

property nb_discrete_contact_pairs_with_cache_hits: Total number of (non CCD) pairs for which contacts are successfully cached (<=nbDiscreteContactPairsTotal) note This includes pairs for which no contacts are generated, it still counts as a cache hit.

property nb_discrete_contact_pairs_with_contacts: Total number of (non CCD) pairs for which at least 1 contact was generated (<=nbDiscreteContactPairsTotal).

property nb_dynamic_rigids: The number of dynamic rigid bodies.

property nb_kinematic_rigids: The number of kinematic rigid bodies.

property nb_lost_pairs: Number of lost pairs from BP this frame.

property nb_lost_touches: Number of lost touches from NP this frame.

property nb_new_pairs: Number of new pairs found by BP this frame.

property nb_new_touches: Number of new touches found by NP this frame.

property nb_partitions: Number of partitions used by the solver this frame.

property nb_plane_shapes: The number of plane shapes.

property nb_sphere_shapes: The number of sphere shapes.

property nb_static_rigids: The number of static rigid bodies.

property nb_trimesh_shapes: The number of triangle mesh shapes.

property peak_constraint_memory: The peak amount of memory (in bytes) that was allocated for constraints (this includes joints) in the current simulation step.

property required_contact_constraint_memory: The total required size (in bytes) of the contact constraints in the current simulation step.

class omni.physx.bindings._physx.PhysxCollisionRepresentationResult

Collision representation result

Members:

RESULT_VALID

RESULT_ERROR_NOT_READY

RESULT_ERROR_INVALID_PARSING

RESULT_ERROR_COOKING_FAILED

RESULT_ERROR_UNSUPPORTED_APPROXIMATION

RESULT_ERROR_INVALID_RESULT

RESULT_ERROR_COOKING_FAILED = <PhysxCollisionRepresentationResult.RESULT_ERROR_COOKING_FAILED: 3>

RESULT_ERROR_INVALID_PARSING = <PhysxCollisionRepresentationResult.RESULT_ERROR_INVALID_PARSING: 2>

RESULT_ERROR_INVALID_RESULT = <PhysxCollisionRepresentationResult.RESULT_ERROR_INVALID_RESULT: 5>

RESULT_ERROR_NOT_READY = <PhysxCollisionRepresentationResult.RESULT_ERROR_NOT_READY: 1>

RESULT_ERROR_UNSUPPORTED_APPROXIMATION = <PhysxCollisionRepresentationResult.RESULT_ERROR_UNSUPPORTED_APPROXIMATION: 4>

RESULT_VALID = <PhysxCollisionRepresentationResult.RESULT_VALID: 0>

property name

property value

class omni.physx.bindings._physx.PhysxCollisionRepresentationTask

Task returned by request_convex_collision_representation

property task: Task handle

class omni.physx.bindings._physx.PhysxConvexMeshData

A convex mesh made of vertices, indices and polygons

property indices

property polygons

property vertices

class omni.physx.bindings._physx.PhysxConvexMeshPolygon

A polygon of a convex mesh

property index_base

property num_vertices

property plane

class omni.physx.bindings._physx.PhysxPropertyQueryColliderResponse

Collider query response.

property aabb_local_max: AABB Max Local Bound

property aabb_local_min: AABB Min Local Bound

property path_id: USD Path

property result: Result

property stage_id: USD Stage

property volume: Volume of the collider

class omni.physx.bindings._physx.PhysxPropertyQueryMode

Query mode.

Members:

QUERY_RIGID_BODY_WITH_COLLIDERS : Query rigid body and its colliders

QUERY_RIGID_BODY_WITH_COLLIDERS = <PhysxPropertyQueryMode.QUERY_RIGID_BODY_WITH_COLLIDERS: 0>

property name

property value

class omni.physx.bindings._physx.PhysxPropertyQueryResult

Query result enumeration.

Members:

VALID : Result is valid

ERROR_UNKNOWN_QUERY_MODE : The requested query mode is unknown

ERROR_INVALID_USD_PATH : Result invalid because of an invalid USD path

ERROR_INVALID_USD_STAGE : Result invalid because of an invalid or expired USD stage

ERROR_INVALID_USD_PRIM : Result invalid because of an invalid or deleted USD prim

ERROR_PARSING : Result invalid because parsing USD failed

ERROR_TIMEOUT : Result invalid because async operation exceeds timeout

ERROR_RUNTIME : Result invalid because PhysX runtime is in invalid state

ERROR_INVALID_USD_PATH = <PhysxPropertyQueryResult.ERROR_INVALID_USD_PATH: 2>

ERROR_INVALID_USD_PRIM = <PhysxPropertyQueryResult.ERROR_INVALID_USD_PRIM: 4>

ERROR_INVALID_USD_STAGE = <PhysxPropertyQueryResult.ERROR_INVALID_USD_STAGE: 3>

ERROR_PARSING = <PhysxPropertyQueryResult.ERROR_PARSING: 5>

ERROR_RUNTIME = <PhysxPropertyQueryResult.ERROR_RUNTIME: 7>

ERROR_TIMEOUT = <PhysxPropertyQueryResult.ERROR_TIMEOUT: 6>

ERROR_UNKNOWN_QUERY_MODE = <PhysxPropertyQueryResult.ERROR_UNKNOWN_QUERY_MODE: 1>

VALID = <PhysxPropertyQueryResult.VALID: 0>

property name

property value

class omni.physx.bindings._physx.PhysxPropertyQueryRigidBodyResponse

Rigid body query response.

property center_of_mass: Center of Mass

property inertia: Inertia

property mass: Mass

property path_id: USD Path

property principal_axes: Principal Axes Quaternion

property result: Result

property stage_id: USD Stage

property type: Type

class omni.physx.bindings._physx.PhysxPropertyQueryRigidBodyResponseType

Query result.

Members:

RIGID_DYNAMIC : Body is a rigid dynamic

RIGID_DYNAMIC = <PhysxPropertyQueryRigidBodyResponseType.RIGID_DYNAMIC: 0>

property name

property value

class omni.physx.bindings._physx.RaycastHit: Raycast hit results structure.

class omni.physx.bindings._physx.SceneQueryHitLocation

Scene query hit location results structure.

property distance: Hit location distance.

property face_index: Hit location face index.

property material: Path string to the collider material that was hit.

property material_encoded: Encoded SdfPath to the collider material that was hit. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

property normal: Hit location normal.

property position: Hit location position.

class omni.physx.bindings._physx.SceneQueryHitObject

Scene query hit results structure.

property collision: Path string to the collision that was hit.

property collision_encoded: Encoded SdfPath to the collision that was hit. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

property protoIndex: ProtoIndex, filled for pointInstancers otherwise 0xFFFFFFFF.

property rigid_body: Path string to the rigid body that was hit.

property rigid_body_encoded: Encoded SdfPath to the rigid body that was hit. PhysicsSchemaTools.decodeSdfPath will return SdfPath.

class omni.physx.bindings._physx.SimulationEvent

Simulation events used by simulation event stream.

Members:

RESUMED : Simulation resumed, no additional data are send in the event

PAUSED : Simulation paused, no additional data are send in the event

STOPPED : Simulation stopped, no additional data are send in the event

CONTACT_FOUND : Contact found event header: sends header information regarding which colliders started to collide; contains the following in a dictionary:
'actor0':int2 - Usd path to rigid body actor 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'actor1':int2 - Usd path to rigid body actor 1 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'collider0':int2 - Usd path to collider 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'collider1':int2 - Usd path to collider 1 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'numContactData':int - Num contact data sent after the header is sent.
'stageId':long1 - Current USD stage id, long array with one item.
CONTACT_LOST : Contact lost event header: sends header information regarding which colliders lost contact; contains the following in a dictionary:
'actor0':int2 - Usd path to rigid body actor 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'actor1':int2 - Usd path to rigid body actor 1 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'collider0':int2 - Usd path to collider 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'collider1':int2 - Usd path to collider 1 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'numContactData':int - Num contact data sent after the header is sent.
'stageId':long1 - Current USD stage id, long array with one item.
CONTACT_PERSISTS : Contact persists event header: sends header information regarding which colliders are still in contact; contains the following in a dictionary:
'actor0':int2 - Usd path to rigid body actor 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'actor1':int2 - Usd path to rigid body actor 1 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'collider0':int2 - Usd path to collider 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'collider1':int2 - Usd path to collider 1 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'numContactData':int - Num contact data sent after the header is sent.
'stageId':long1 - Current USD stage id, long array with one item.
CONTACT_DATA : Contact data sent after each header contact information is sent; contains the following in a dictionary:
'position':float3 - Contact position
'normal':float3 - Contact normal
'impulse':float3 - Contact impulse
'separation':float - Separation value for collisions.
'faceIndex0':int - USD face index 0.
'faceIndex1':int - USD face index 0.
'material0':int2 - Usd path to material 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
'material1':int2 - Usd path to material 0 decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
JOINT_BREAK : Joint break event; contains the following in a dictionary:
'jointPath':int2 - Usd path to joint that did break decoded into two ints. PhysicsSchemaTools.decodeSdfPath will return SdfPath.
POINT_GRABBED : Point grabbed; contains the following in a dictionary:
'grabbed_position':float3 - Current world position of grabbed point.
'grab_force_position':float3 - Current world position of the position being grabbed towards.
POINT_RELEASED : Point released.

POINT_PUSHED : Point pushed; contains the following in a dictionary:
'pushed_position':float3 - World position of point pushed.
ATTACHED_TO_STAGE : When physx stage attachment (initialization) finished.

DETACHED_FROM_STAGE : When physx stage detachment (deinitialization) finished.

ATTACHED_TO_STAGE = <SimulationEvent.ATTACHED_TO_STAGE: 10>

CONTACT_DATA = <SimulationEvent.CONTACT_DATA: 6>

CONTACT_FOUND = <SimulationEvent.CONTACT_FOUND: 3>

CONTACT_LOST = <SimulationEvent.CONTACT_LOST: 4>

CONTACT_PERSISTS = <SimulationEvent.CONTACT_PERSISTS: 5>

DETACHED_FROM_STAGE = <SimulationEvent.DETACHED_FROM_STAGE: 11>

JOINT_BREAK = <SimulationEvent.JOINT_BREAK: 7>

PAUSED = <SimulationEvent.PAUSED: 1>

POINT_GRABBED = <SimulationEvent.POINT_GRABBED: 8>

POINT_PUSHED = <SimulationEvent.POINT_PUSHED: 12>

POINT_RELEASED = <SimulationEvent.POINT_RELEASED: 9>

RESUMED = <SimulationEvent.RESUMED: 0>

STOPPED = <SimulationEvent.STOPPED: 2>

property name

property value

class omni.physx.bindings._physx.SweepHit: Sweep hit results structure.

class omni.physx.bindings._physx.TriggerEventData

Parameters for trigger event callback.

property event_type: Event Type (enter or leave)

property other_body_prim_id: USD Path of the body containgint the other collider prim entering trigger

property other_collider_prim_id: USD Path of other prim entering trigger

property stage_id: USD Stage

property subscription_id: Id of the subscription returned by subscribe_physics_trigger_report_events

property trigger_body_prim_id: USD Path of the body containg the collider prim representing the trigger

property trigger_collider_prim_id: USD Path of prim representing the trigger

class omni.physx.bindings._physx.TriggerEventType

Trigger Event type.

Members:

TRIGGER_ON_ENTER : The collider has entered trigger volume

TRIGGER_ON_LEAVE : The collider has left trigger volume

TRIGGER_ON_ENTER = <TriggerEventType.TRIGGER_ON_ENTER: 0>

TRIGGER_ON_LEAVE = <TriggerEventType.TRIGGER_ON_LEAVE: 1>

property name

property value

class omni.physx.bindings._physx.VisualizerMode

Visualization mode for collider, particles, deformables, etc. object types.

ALL = 2

NONE = 0

SELECTED = 1

omni.physx.bindings._physx.acquire_physx_attachment_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.IPhysxAttachment

omni.physx.bindings._physx.acquire_physx_benchmarks_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.IPhysxBenchmarks

omni.physx.bindings._physx.acquire_physx_cooking_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.PhysXCooking

omni.physx.bindings._physx.acquire_physx_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.PhysX

omni.physx.bindings._physx.acquire_physx_property_query_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.IPhysxPropertyQuery

omni.physx.bindings._physx.acquire_physx_replicator_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.IPhysxReplicator

omni.physx.bindings._physx.acquire_physx_scene_query_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.PhysXSceneQuery

omni.physx.bindings._physx.acquire_physx_simulation_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.IPhysxSimulation

omni.physx.bindings._physx.acquire_physx_stage_update_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.IPhysxStageUpdate

omni.physx.bindings._physx.acquire_physx_statistics_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.IPhysxStatistics

omni.physx.bindings._physx.acquire_physx_visualization_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.PhysXVisualization

omni.physx.bindings._physx.acquire_physxunittests_interface(plugin_name: str = None, library_path: str = None) → omni.physx.bindings._physx.PhysXUnitTests

omni.physx.bindings._physx.ancestorHasAPI(arg0: TfType, arg1: UsdPrim) → bool

omni.physx.bindings._physx.descendantHasAPI(arg0: TfType, arg1: UsdPrim) → bool

omni.physx.bindings._physx.hasconflictingapis_ArticulationRoot(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.hasconflictingapis_CollisionAPI(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.hasconflictingapis_PhysxDeformableBodyAPI(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.hasconflictingapis_PhysxDeformableSurfaceAPI(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.hasconflictingapis_PhysxHairAPI(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.hasconflictingapis_PhysxParticleClothAPI(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.hasconflictingapis_PhysxParticleSamplingAPI(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.hasconflictingapis_Precompute(arg0: UsdPrim) → Annotated[List[bool], FixedSize(3)]

omni.physx.bindings._physx.hasconflictingapis_RigidBodyAPI(arg0: UsdPrim, arg1: bool) → bool

omni.physx.bindings._physx.isOverConflictingApisSubtreeLimit(arg0: UsdPrim, arg1: int) → bool

omni.physx.bindings._physx.release_physx_attachment_interface(arg0: omni.physx.bindings._physx.IPhysxAttachment) → None

omni.physx.bindings._physx.release_physx_benchmarks_interface(arg0: omni.physx.bindings._physx.IPhysxBenchmarks) → None

omni.physx.bindings._physx.release_physx_cooking_interface(arg0: omni.physx.bindings._physx.PhysXCooking) → None

omni.physx.bindings._physx.release_physx_interface(arg0: omni.physx.bindings._physx.PhysX) → None

omni.physx.bindings._physx.release_physx_interface_scripting(arg0: omni.physx.bindings._physx.PhysX) → None

omni.physx.bindings._physx.release_physx_property_query_interface(arg0: omni.physx.bindings._physx.IPhysxPropertyQuery) → None

omni.physx.bindings._physx.release_physx_replicator_interface(arg0: omni.physx.bindings._physx.IPhysxReplicator) → None

omni.physx.bindings._physx.release_physx_replicator_interface_scripting(arg0: omni.physx.bindings._physx.IPhysxReplicator) → None

omni.physx.bindings._physx.release_physx_scene_query_interface(arg0: omni.physx.bindings._physx.PhysXSceneQuery) → None

omni.physx.bindings._physx.release_physx_simulation_interface(arg0: omni.physx.bindings._physx.IPhysxSimulation) → None

omni.physx.bindings._physx.release_physx_stage_update_interface(arg0: omni.physx.bindings._physx.IPhysxStageUpdate) → None

omni.physx.bindings._physx.release_physx_stage_update_interface_scripting(arg0: omni.physx.bindings._physx.IPhysxStageUpdate) → None

omni.physx.bindings._physx.release_physx_statistics_interface(arg0: omni.physx.bindings._physx.IPhysxStatistics) → None

omni.physx.bindings._physx.release_physx_statistics_interface_scripting(arg0: omni.physx.bindings._physx.IPhysxStatistics) → None

omni.physx.bindings._physx.release_physx_visualization_interface(arg0: omni.physx.bindings._physx.PhysXVisualization) → None

omni.physx.bindings._physx.release_physxunittests_interface(arg0: omni.physx.bindings._physx.PhysXUnitTests) → None