usdrt/scenegraph/usd/usdPhysics/tokens.h

File members: usdrt/scenegraph/usd/usdPhysics/tokens.h

// Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#pragma once

// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//
// This is an automatically generated file (by usdGenSchema.py).
// Do not hand-edit!
//
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
#include <usdrt/scenegraph/base/tf/token.h>

namespace usdrt
{

struct UsdPhysicsTokensType
{
    UsdPhysicsTokensType();
    const TfToken acceleration;
    const TfToken angular;
    const TfToken boundingCube;
    const TfToken boundingSphere;
    const TfToken colliders;
    const TfToken convexDecomposition;
    const TfToken convexHull;
    const TfToken distance;
    const TfToken drive;
    const TfToken force;
    const TfToken kilogramsPerUnit;
    const TfToken limit;
    const TfToken linear;
    const TfToken meshSimplification;
    const TfToken none;
    const TfToken physicsAngularVelocity;
    const TfToken physicsApproximation;
    const TfToken physicsAxis;
    const TfToken physicsBody0;
    const TfToken physicsBody1;
    const TfToken physicsBreakForce;
    const TfToken physicsBreakTorque;
    const TfToken physicsCenterOfMass;
    const TfToken physicsCollisionEnabled;
    const TfToken physicsConeAngle0Limit;
    const TfToken physicsConeAngle1Limit;
    const TfToken physicsDamping;
    const TfToken physicsDensity;
    const TfToken physicsDiagonalInertia;
    const TfToken physicsDynamicFriction;
    const TfToken physicsExcludeFromArticulation;
    const TfToken physicsFilteredGroups;
    const TfToken physicsFilteredPairs;
    const TfToken physicsGravityDirection;
    const TfToken physicsGravityMagnitude;
    const TfToken physicsHigh;
    const TfToken physicsInvertFilteredGroups;
    const TfToken physicsJointEnabled;
    const TfToken physicsKinematicEnabled;
    const TfToken physicsLocalPos0;
    const TfToken physicsLocalPos1;
    const TfToken physicsLocalRot0;
    const TfToken physicsLocalRot1;
    const TfToken physicsLow;
    const TfToken physicsLowerLimit;
    const TfToken physicsMass;
    const TfToken physicsMaxDistance;
    const TfToken physicsMaxForce;
    const TfToken physicsMergeGroup;
    const TfToken physicsMinDistance;
    const TfToken physicsPrincipalAxes;
    const TfToken physicsRestitution;
    const TfToken physicsRigidBodyEnabled;
    const TfToken physicsSimulationOwner;
    const TfToken physicsStartsAsleep;
    const TfToken physicsStaticFriction;
    const TfToken physicsStiffness;
    const TfToken physicsTargetPosition;
    const TfToken physicsTargetVelocity;
    const TfToken physicsType;
    const TfToken physicsUpperLimit;
    const TfToken physicsVelocity;
    const TfToken rotX;
    const TfToken rotY;
    const TfToken rotZ;
    const TfToken transX;
    const TfToken transY;
    const TfToken transZ;
    const TfToken x;
    const TfToken y;
    const TfToken z;
    const std::vector<TfToken> allTokens;
};

inline UsdPhysicsTokensType::UsdPhysicsTokensType()
    : acceleration("acceleration"),
      angular("angular"),
      boundingCube("boundingCube"),
      boundingSphere("boundingSphere"),
      colliders("colliders"),
      convexDecomposition("convexDecomposition"),
      convexHull("convexHull"),
      distance("distance"),
      drive("drive"),
      force("force"),
      kilogramsPerUnit("kilogramsPerUnit"),
      limit("limit"),
      linear("linear"),
      meshSimplification("meshSimplification"),
      none("none"),
      physicsAngularVelocity("physics:angularVelocity"),
      physicsApproximation("physics:approximation"),
      physicsAxis("physics:axis"),
      physicsBody0("physics:body0"),
      physicsBody1("physics:body1"),
      physicsBreakForce("physics:breakForce"),
      physicsBreakTorque("physics:breakTorque"),
      physicsCenterOfMass("physics:centerOfMass"),
      physicsCollisionEnabled("physics:collisionEnabled"),
      physicsConeAngle0Limit("physics:coneAngle0Limit"),
      physicsConeAngle1Limit("physics:coneAngle1Limit"),
      physicsDamping("physics:damping"),
      physicsDensity("physics:density"),
      physicsDiagonalInertia("physics:diagonalInertia"),
      physicsDynamicFriction("physics:dynamicFriction"),
      physicsExcludeFromArticulation("physics:excludeFromArticulation"),
      physicsFilteredGroups("physics:filteredGroups"),
      physicsFilteredPairs("physics:filteredPairs"),
      physicsGravityDirection("physics:gravityDirection"),
      physicsGravityMagnitude("physics:gravityMagnitude"),
      physicsHigh("physics:high"),
      physicsInvertFilteredGroups("physics:invertFilteredGroups"),
      physicsJointEnabled("physics:jointEnabled"),
      physicsKinematicEnabled("physics:kinematicEnabled"),
      physicsLocalPos0("physics:localPos0"),
      physicsLocalPos1("physics:localPos1"),
      physicsLocalRot0("physics:localRot0"),
      physicsLocalRot1("physics:localRot1"),
      physicsLow("physics:low"),
      physicsLowerLimit("physics:lowerLimit"),
      physicsMass("physics:mass"),
      physicsMaxDistance("physics:maxDistance"),
      physicsMaxForce("physics:maxForce"),
      physicsMergeGroup("physics:mergeGroup"),
      physicsMinDistance("physics:minDistance"),
      physicsPrincipalAxes("physics:principalAxes"),
      physicsRestitution("physics:restitution"),
      physicsRigidBodyEnabled("physics:rigidBodyEnabled"),
      physicsSimulationOwner("physics:simulationOwner"),
      physicsStartsAsleep("physics:startsAsleep"),
      physicsStaticFriction("physics:staticFriction"),
      physicsStiffness("physics:stiffness"),
      physicsTargetPosition("physics:targetPosition"),
      physicsTargetVelocity("physics:targetVelocity"),
      physicsType("physics:type"),
      physicsUpperLimit("physics:upperLimit"),
      physicsVelocity("physics:velocity"),
      rotX("rotX"),
      rotY("rotY"),
      rotZ("rotZ"),
      transX("transX"),
      transY("transY"),
      transZ("transZ"),
      x("X"),
      y("Y"),
      z("Z")
{
}

struct UsdPhysicsTokensTypeAccessor
{
    const UsdPhysicsTokensType* operator->()
    {
        static const UsdPhysicsTokensType tokens;
        return &tokens;
    }
};

inline UsdPhysicsTokensTypeAccessor UsdPhysicsTokens;

} // namespace usdrt