parseDesc.h

Go to the documentation of this file.

//
// Copyright 2024 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef USDPHYSICS_PARSE_DESC_H
#define USDPHYSICS_PARSE_DESC_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/collectionMembershipQuery.h"
 
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/quatf.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
// -------------------------------------------------------------------------- //
// PHYSICSPARSEDESC                                                           //
// -------------------------------------------------------------------------- //
 
const float usdPhysicsSentinelLimit = 0.5e38f;
 
enum class UsdPhysicsObjectType
{
    Undefined,
 
    Scene,
 
    RigidBody,
 
    SphereShape,
    CubeShape,
    CapsuleShape,
    Capsule1Shape,
    CylinderShape,
    Cylinder1Shape,
    ConeShape,
    MeshShape,
    PlaneShape,
    CustomShape,
    SpherePointsShape,
 
    FixedJoint,
    RevoluteJoint,
    PrismaticJoint,
    SphericalJoint,
    DistanceJoint,
    D6Joint,
    CustomJoint,
 
    RigidBodyMaterial,
 
    Articulation,
 
    CollisionGroup,
 
    Last,
};
 
enum class UsdPhysicsAxis
{
    X,
    Y,
    Z
};
 
enum class UsdPhysicsJointDOF
{
    Distance,
    TransX,
    TransY,
    TransZ,
    RotX,
    RotY,
    RotZ
};
 
struct UsdPhysicsObjectDesc
{
    UsdPhysicsObjectDesc(UsdPhysicsObjectType inType) : 
        type(inType), isValid(true)
    {
    }
 
    virtual ~UsdPhysicsObjectDesc() = default;
 
    UsdPhysicsObjectType type;
    SdfPath primPath;
    bool isValid;
};
 
struct UsdPhysicsRigidBodyMaterialDesc : UsdPhysicsObjectDesc
{
    UsdPhysicsRigidBodyMaterialDesc() : 
        UsdPhysicsObjectDesc(UsdPhysicsObjectType::RigidBodyMaterial), 
        staticFriction(0.0f), dynamicFriction(0.0f), restitution(0.0f), 
        density(-1.0f)
    {
    }
 
    bool operator == (const UsdPhysicsRigidBodyMaterialDesc& /*desc*/) const
    {
        return false;
    }
 
    float staticFriction;
    float dynamicFriction;
    float restitution;
    float density;
};
 
struct UsdPhysicsSceneDesc : UsdPhysicsObjectDesc
{
    UsdPhysicsSceneDesc() : 
        UsdPhysicsObjectDesc(UsdPhysicsObjectType::Scene), 
        gravityDirection(0.0f, 0.0f, 0.0f), gravityMagnitude(-INFINITY)
    {        
    }
 
    bool operator == (const UsdPhysicsSceneDesc& /*desc*/) const
    {
        return false;
    }
 
    GfVec3f gravityDirection;
    float gravityMagnitude;
};
 
struct UsdPhysicsCollisionGroupDesc : UsdPhysicsObjectDesc
{
    UsdPhysicsCollisionGroupDesc():
        UsdPhysicsObjectDesc(UsdPhysicsObjectType::CollisionGroup)
    {        
    }
 
    bool operator == (const UsdPhysicsCollisionGroupDesc& /*desc*/) const
    {
        return false;
    }
 
    const SdfPathVector& GetFilteredGroups() const
    {
        return filteredGroups;
    }
 
    const SdfPathVector& GetMergedGroups() const
    {
        return mergedGroups;
    }
 
    bool invertFilteredGroups;
    SdfPathVector filteredGroups;
    std::string mergeGroupName;
    SdfPathVector mergedGroups;
};
 
struct UsdPhysicsShapeDesc : UsdPhysicsObjectDesc
{
    UsdPhysicsShapeDesc(UsdPhysicsObjectType inType)
        : UsdPhysicsObjectDesc(inType), localPos(0.0f, 0.0f, 0.0f), 
        localRot(1.0f, 0.0f, 0.0f, 0.0f), 
        localScale(1.0f, 1.0f, 1.0f), collisionEnabled(true)
    {
    }
 
    const SdfPathVector& GetMaterials() const
    {
        return materials;
    }
 
    const SdfPathVector& GetSimulationOwners() const
    {
        return simulationOwners;
    }
 
    const SdfPathVector& GetFilteredCollisions() const
    {
        return filteredCollisions;
    }
 
    const SdfPathVector& GetCollisionGroups() const
    {
        return collisionGroups;
    }
 
 
    SdfPath rigidBody;
    GfVec3f localPos;
    GfQuatf localRot;
    GfVec3f localScale;
    SdfPathVector materials;
    SdfPathVector simulationOwners;
    SdfPathVector filteredCollisions;
    SdfPathVector collisionGroups;
    bool collisionEnabled;
};
 
struct UsdPhysicsSphereShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsSphereShapeDesc(float inRadius = 0.0f) : 
        UsdPhysicsShapeDesc(UsdPhysicsObjectType::SphereShape), radius(inRadius)
    {        
    }
 
    bool operator == (const UsdPhysicsSphereShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    float radius;
};
 
struct UsdPhysicsCapsuleShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsCapsuleShapeDesc(float inRadius = 0.0f, float half_height = 0.0f,
        UsdPhysicsAxis cap_axis = UsdPhysicsAxis::X)
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::CapsuleShape), 
        radius(inRadius), halfHeight(half_height), axis(cap_axis)
    {        
    }
 
    bool operator == (const UsdPhysicsCapsuleShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    float radius;
    float halfHeight;
    UsdPhysicsAxis axis;
};
 
struct UsdPhysicsCapsule1ShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsCapsule1ShapeDesc(float inTopRadius = 0.0f,
        float inBottomRadius = 0.0f, float half_height = 0.0f,
        UsdPhysicsAxis cap_axis = UsdPhysicsAxis::X)
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::Capsule1Shape), 
        topRadius(inTopRadius), bottomRadius(inBottomRadius),
        halfHeight(half_height), axis(cap_axis)
    {        
    }
 
    bool operator == (const UsdPhysicsCapsule1ShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    float topRadius;
    float bottomRadius;
    float halfHeight;
    UsdPhysicsAxis axis;
};
 
struct UsdPhysicsCylinderShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsCylinderShapeDesc(float inRadius = 0.0f, float half_height = 0.0f,
        UsdPhysicsAxis cap_axis = UsdPhysicsAxis::X)
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::CylinderShape), 
        radius(inRadius), halfHeight(half_height), axis(cap_axis)
    {        
    }
 
    bool operator == (const UsdPhysicsCylinderShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    float radius;
    float halfHeight;
    UsdPhysicsAxis axis;
};
 
struct UsdPhysicsCylinder1ShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsCylinder1ShapeDesc(float inTopRadius = 0.0f, 
        float inBottomRadius = 0.0f, float half_height = 0.0f,
        UsdPhysicsAxis cap_axis = UsdPhysicsAxis::X)
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::Cylinder1Shape), 
        topRadius(inTopRadius), bottomRadius(inBottomRadius),
        halfHeight(half_height), axis(cap_axis)
    {        
    }
 
    bool operator == (const UsdPhysicsCylinder1ShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    float topRadius;
    float bottomRadius;
    float halfHeight;
    UsdPhysicsAxis axis;
};
 
struct UsdPhysicsConeShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsConeShapeDesc(float inRadius = 0.0f, float half_height = 0.0f,
        UsdPhysicsAxis cap_axis = UsdPhysicsAxis::X)
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::ConeShape), radius(inRadius), 
        halfHeight(half_height), axis(cap_axis)
    {        
    }
 
    bool operator == (const UsdPhysicsConeShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    float radius;
    float halfHeight;
    UsdPhysicsAxis axis;
};
 
struct UsdPhysicsPlaneShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsPlaneShapeDesc(UsdPhysicsAxis up_axis = UsdPhysicsAxis::X)
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::PlaneShape), axis(up_axis)
    {        
    }
 
    bool operator == (const UsdPhysicsPlaneShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    UsdPhysicsAxis axis;
};
 
 
struct UsdPhysicsCustomShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsCustomShapeDesc()
    : UsdPhysicsShapeDesc(UsdPhysicsObjectType::CustomShape)
    {        
    }
 
    bool operator == (const UsdPhysicsCustomShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    TfToken customGeometryToken;
};
 
struct UsdPhysicsCubeShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsCubeShapeDesc(const GfVec3f& inHalfExtents = GfVec3f(1.0f))
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::CubeShape), 
        halfExtents(inHalfExtents)
    {
    }
 
    bool operator == (const UsdPhysicsCubeShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    GfVec3f halfExtents;
};
 
struct UsdPhysicsMeshShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsMeshShapeDesc()
        : UsdPhysicsShapeDesc(UsdPhysicsObjectType::MeshShape), 
        meshScale(1.0f, 1.0f, 1.0f), 
        doubleSided(false)
    {
    }
 
    bool operator == (const UsdPhysicsMeshShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    TfToken GetApproximation() const
    {
        return approximation;
    }
 
    TfToken approximation;
    GfVec3f meshScale;
    bool doubleSided;
};
 
struct UsdPhysicsSpherePoint
{
    bool operator == (const UsdPhysicsSpherePoint& /*desc*/) const
    {
        return false;
    }
 
    GfVec3f center; 
 
    float radius;
};
 
struct UsdPhysicsSpherePointsShapeDesc : UsdPhysicsShapeDesc
{
    UsdPhysicsSpherePointsShapeDesc()
    : UsdPhysicsShapeDesc(UsdPhysicsObjectType::SpherePointsShape)
    {
    }
 
    bool operator == (const UsdPhysicsSpherePointsShapeDesc& /*desc*/) const
    {
        return false;
    }
 
    std::vector<UsdPhysicsSpherePoint> spherePoints;
};
 
struct UsdPhysicsRigidBodyDesc : UsdPhysicsObjectDesc
{
    UsdPhysicsRigidBodyDesc()
        : UsdPhysicsObjectDesc(UsdPhysicsObjectType::RigidBody), 
        position(0.0f, 0.0f, 0.0f), 
        rotation(1.0f, 0.0f, 0.0f, 0.0f),
        scale(1.0f, 1.0f, 1.0f), rigidBodyEnabled(true), kinematicBody(false),
        startsAsleep(false), linearVelocity(0.0f, 0.0f, 0.0f), 
        angularVelocity(0.0f, 0.0f, 0.0f)
    {
    }
 
    bool operator == (const UsdPhysicsRigidBodyDesc& /*desc*/) const
    {
        return false;
    }
 
    const SdfPathVector& GetCollisions() const
    {
        return collisions;
    }
 
    const SdfPathVector& GetFilteredCollisions() const
    {
        return filteredCollisions;
    }
 
    const SdfPathVector& GetSimulationOwners() const
    {
        return simulationOwners;
    }
 
    SdfPathVector collisions;
    SdfPathVector filteredCollisions;
    SdfPathVector simulationOwners;
    GfVec3f position;
    GfQuatf rotation;
    GfVec3f scale;
 
    bool rigidBodyEnabled;
    bool kinematicBody;
    bool startsAsleep;
    GfVec3f linearVelocity;
    GfVec3f angularVelocity;
};
 
struct UsdPhysicsJointLimit
{
    UsdPhysicsJointLimit() : enabled(false), angle0(90.0), angle1(-90.0)
    {
    }
 
    bool operator == (const UsdPhysicsJointLimit& /*desc*/) const
    {
        return false;
    }
 
    bool enabled;
 
    union
    {
        float angle0;
        float lower;
        float minDist;
    };
 
    union
    {
        float angle1;
        float upper;
        float maxDist;
    };
};
 
struct UsdPhysicsJointDrive
{
    UsdPhysicsJointDrive()
        : enabled(false), targetPosition(0.0f), targetVelocity(0.0f), 
        forceLimit(FLT_MAX), stiffness(0.0f), damping(0.0f), acceleration(false)
    {
    }
 
    bool operator == (const UsdPhysicsJointDrive& /*desc*/) const
    {
        return false;
    }
 
    bool enabled;
    float targetPosition;
    float targetVelocity;
    float forceLimit;
    float stiffness;
    float damping;
    bool acceleration;
};
 
 
struct UsdPhysicsArticulationDesc : UsdPhysicsObjectDesc
{
    UsdPhysicsArticulationDesc()
    : UsdPhysicsObjectDesc(UsdPhysicsObjectType::Articulation)
    {
    }
 
    bool operator == (const UsdPhysicsArticulationDesc& /*desc*/) const
    {
        return false;
    }
 
    const SdfPathVector& GetRootPrims() const
    {
        return rootPrims;
    }
 
    const SdfPathVector& GetFilteredCollisions() const
    {
        return filteredCollisions;
    }
 
    const SdfPathVector& GetArticulatedJoints() const
    {
        return articulatedJoints;
    }
 
    const SdfPathVector& GetArticulatedBodies() const
    {
        return articulatedBodies;
    }
 
    SdfPathVector rootPrims;
    SdfPathVector filteredCollisions;
    SdfPathVector articulatedJoints;
    SdfPathVector articulatedBodies;
};
 
using JointLimits = std::vector<
                        std::pair<
                            UsdPhysicsJointDOF, UsdPhysicsJointLimit>>;
using JointDrives = std::vector<
                        std::pair<
                            UsdPhysicsJointDOF, UsdPhysicsJointDrive>>;
 
struct UsdPhysicsJointDesc : public UsdPhysicsObjectDesc
{
    UsdPhysicsJointDesc(UsdPhysicsObjectType inType)
        : UsdPhysicsObjectDesc(inType), localPose0Position(0.0f, 0.0f, 0.0f), 
        localPose0Orientation(1.0f, 0.0f, 0.0f, 0.0f), 
        localPose1Position(0.0f, 0.0f, 0.0f), 
        localPose1Orientation(1.0f, 0.0f, 0.0f, 0.0f), jointEnabled(true),
        breakForce(FLT_MAX), // USD default is none, which is not a float...
        breakTorque(FLT_MAX), excludeFromArticulation(false)
    {
    }
 
    bool operator == (const UsdPhysicsJointDesc& /*desc*/) const
    {
        return false;
    }
 
    SdfPath rel0;
    SdfPath rel1;
    SdfPath body0;
    SdfPath body1;
    GfVec3f localPose0Position;
    GfQuatf localPose0Orientation;
    GfVec3f localPose1Position;
    GfQuatf localPose1Orientation;
    bool jointEnabled;
    float breakForce;
    float breakTorque;
    bool excludeFromArticulation;
    bool collisionEnabled;
};
 
struct UsdPhysicsCustomJointDesc : public UsdPhysicsJointDesc
{
    UsdPhysicsCustomJointDesc()
    : UsdPhysicsJointDesc(UsdPhysicsObjectType::CustomJoint)
    {
    }
 
    bool operator == (const UsdPhysicsCustomJointDesc& /*desc*/) const
    {
        return false;
    }
 
};
 
struct UsdPhysicsFixedJointDesc : public UsdPhysicsJointDesc
{
    UsdPhysicsFixedJointDesc()
    : UsdPhysicsJointDesc(UsdPhysicsObjectType::FixedJoint)
    {
    }
 
    bool operator == (const UsdPhysicsFixedJointDesc& /*desc*/) const
    {
        return false;
    }
};
 
struct UsdPhysicsD6JointDesc : public UsdPhysicsJointDesc
{
    UsdPhysicsD6JointDesc()
    : UsdPhysicsJointDesc(UsdPhysicsObjectType::D6Joint)
    {
    }
 
    bool operator == (const UsdPhysicsD6JointDesc& /*desc*/) const
    {
        return false;
    }
 
    JointLimits jointLimits;
    JointDrives jointDrives;
};
 
struct UsdPhysicsPrismaticJointDesc : public UsdPhysicsJointDesc
{
    UsdPhysicsPrismaticJointDesc()
    : UsdPhysicsJointDesc(UsdPhysicsObjectType::PrismaticJoint), 
    axis(UsdPhysicsAxis::X)
    {
    }
 
    bool operator == (const UsdPhysicsPrismaticJointDesc& /*desc*/) const
    {
        return false;
    }
 
    UsdPhysicsAxis axis;
    UsdPhysicsJointLimit limit;
    UsdPhysicsJointDrive drive;
};
 
struct UsdPhysicsSphericalJointDesc : public UsdPhysicsJointDesc
{
    UsdPhysicsSphericalJointDesc()
    : UsdPhysicsJointDesc(UsdPhysicsObjectType::SphericalJoint), 
    axis(UsdPhysicsAxis::X)
    {
    }
 
    bool operator == (const UsdPhysicsSphericalJointDesc& /*desc*/) const
    {
        return false;
    }
 
    UsdPhysicsAxis axis;
    UsdPhysicsJointLimit limit;
};
 
struct UsdPhysicsRevoluteJointDesc : public UsdPhysicsJointDesc
{
    UsdPhysicsRevoluteJointDesc()
    : UsdPhysicsJointDesc(UsdPhysicsObjectType::RevoluteJoint), 
    axis(UsdPhysicsAxis::X)
    {
    }
 
    bool operator == (const UsdPhysicsRevoluteJointDesc& /*desc*/) const
    {
        return false;
    }
 
    UsdPhysicsAxis axis;
    UsdPhysicsJointLimit limit;
    UsdPhysicsJointDrive drive;
};
 
struct UsdPhysicsDistanceJointDesc : public UsdPhysicsJointDesc
{
    UsdPhysicsDistanceJointDesc() 
    : UsdPhysicsJointDesc(UsdPhysicsObjectType::DistanceJoint), 
    minEnabled(false), maxEnabled(false)
    {
    }
 
    bool operator == (const UsdPhysicsDistanceJointDesc& /*desc*/) const
    {
        return false;
    }
 
    bool minEnabled;
    bool maxEnabled;
    UsdPhysicsJointLimit limit;
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif