From 178fb49c2b2ff48f59653515ab09b9cafca31b7a Mon Sep 17 00:00:00 2001 From: Sam Haves Date: Fri, 16 May 2025 08:53:16 -0700 Subject: [PATCH] Fix namespacing in USD schema. PiperOrigin-RevId: 759632714 Change-Id: I666ca0e5b7f264f63eae0bbb39f0403654fb1c56 --- .../usd/mjcPhysics/generatedSchema.usda | 236 +++++++------- src/experimental/usd/mjcPhysics/sceneAPI.cpp | 294 +++++++++--------- src/experimental/usd/mjcPhysics/sceneAPI.h | 104 +++---- src/experimental/usd/mjcPhysics/schema.usda | 98 +++--- src/experimental/usd/mjcPhysics/tokens.cpp | 202 ++++++------ src/experimental/usd/mjcPhysics/tokens.h | 196 ++++++------ 6 files changed, 563 insertions(+), 567 deletions(-) diff --git a/src/experimental/usd/mjcPhysics/generatedSchema.usda b/src/experimental/usd/mjcPhysics/generatedSchema.usda index 4cb4d177..ee17510b 100644 --- a/src/experimental/usd/mjcPhysics/generatedSchema.usda +++ b/src/experimental/usd/mjcPhysics/generatedSchema.usda @@ -7,214 +7,214 @@ class "SceneAPI" ( doc = "API providing global simulation options for Mujoco." ) { - uniform int[] mjc:physics:actuatorgroupdisable ( + uniform bool mjc:flag:actuation = 1 ( + displayName = "Actuation Forces Toggle" + doc = "Enables all standard computations related to actuator forces, including actuator dynamics." + ) + uniform bool mjc:flag:autoreset = 1 ( + displayName = "Automatic Simulation Reset Toggle" + doc = "Enables the automatic resetting of the simulation state when numerical issues are detected." + ) + uniform bool mjc:flag:clampctrl = 1 ( + displayName = "Control Input Clamping Toggle" + doc = "Enables the clamping of control inputs to all actuators, according to actuator-specific attributes." + ) + uniform bool mjc:flag:constraint = 1 ( + displayName = "Constraint Solver Toggle" + doc = "Enables constraint solver." + ) + uniform bool mjc:flag:contact = 1 ( + displayName = "Contact Constraints and Collision Detection Toggle" + doc = "Enables collision detection and all standard computations related to contact constraints." + ) + uniform bool mjc:flag:energy = 0 ( + displayName = "Energy Computation Toggle" + doc = "Enables the computation of potential and kinetic energy (mjData.energy[0,1])." + ) + uniform bool mjc:flag:equality = 1 ( + displayName = "Equality Constraints Toggle" + doc = "Enables all standard computations related to equality constraints." + ) + uniform bool mjc:flag:eulerdamp = 1 ( + displayName = "Euler Integrator Damping Toggle" + doc = "Enables implicit integration with respect to joint damping in the Euler integrator." + ) + uniform bool mjc:flag:filterparent = 1 ( + displayName = "Parent-Child Contact Filtering Toggle" + doc = "Enables the filtering of contact pairs where the two geoms belong to a parent and child body." + ) + uniform bool mjc:flag:frictionloss = 1 ( + displayName = "Friction Loss Constraints Toggle" + doc = "Enables all standard computations related to friction loss constraints." + ) + uniform bool mjc:flag:fwdinv = 0 ( + displayName = "Forward/Inverse Dynamics Comparison Toggle" + doc = "Enables the automatic comparison of forward and inverse dynamics." + ) + uniform bool mjc:flag:gravity = 1 ( + displayName = "Gravity Toggle" + doc = "Enables the application of gravitational acceleration as defined in mjOption." + ) + uniform bool mjc:flag:invdiscrete = 0 ( + displayName = "Discrete-Time Inverse Dynamics Toggle" + doc = "Enables discrete-time inverse dynamics with mj_inverse for integrators other than RK4." + ) + uniform bool mjc:flag:island = 0 ( + displayName = "Constraint Island Discovery Toggle" + doc = "Enables the discovery of constraint islands." + ) + uniform bool mjc:flag:limit = 1 ( + displayName = "Joint and Tendon Limit Constraints Toggle" + doc = "Enables all standard computations related to joint and tendon limit constraints." + ) + uniform bool mjc:flag:midphase = 1 ( + displayName = "Mid-Phase Collision Filtering Toggle" + doc = "Enables mid-phase collision filtering using a static AABB bounding volume hierarchy (BVH)." + ) + uniform bool mjc:flag:multiccd = 0 ( + displayName = "Multiple Contact Collision Detection (CCD) Toggle" + doc = "Enables multiple-contact collision detection for geom pairs using a general-purpose convex-convex collider." + ) + uniform bool mjc:flag:nativeccd = 1 ( + displayName = "Native Convex Collision Detection Toggle" + doc = "Enables the native convex collision detection pipeline instead of using the libccd library." + ) + uniform bool mjc:flag:override = 0 ( + displayName = "Contact Override Mechanism Toggle" + doc = "Enables the contact override mechanism." + ) + uniform bool mjc:flag:passive = 1 ( + displayName = "Passive Forces Toggle" + doc = "Enables the simulation of joint and tendon spring-dampers, fluid dynamics forces, and custom passive forces." + ) + uniform bool mjc:flag:refsafe = 1 ( + displayName = "Solver Reference Safety Mechanism Toggle" + doc = "Enables a safety mechanism that prevents instabilities due to solref[0] being too small compared to the simulation timestep." + ) + uniform bool mjc:flag:sensor = 1 ( + displayName = "Sensor Computations Toggle" + doc = "Enables all computations related to sensors." + ) + uniform bool mjc:flag:warmstart = 1 ( + displayName = "Solver Warm-Starting Toggle" + doc = "Enables warm-starting of the constraint solver, using the solution from the previous time step to initialize the iterative optimization." + ) + uniform int[] mjc:option:actuatorgroupdisable ( displayName = "Actuator Group Disable" doc = "List of actuator groups to disable." ) - uniform double mjc:physics:apirate = 100 ( + uniform double mjc:option:apirate = 100 ( displayName = "ApiRate" doc = """Determines the rate (in Hz) at which an external API allows the update function to be executed.""" ) - uniform int mjc:physics:ccd_iterations = 50 ( + uniform int mjc:option:ccd_iterations = 50 ( displayName = "CCD Iterations" doc = "Maximum number of iterations of the algorithm used for convex collisions." ) - uniform double mjc:physics:ccd_tolerance = 0.000001 ( + uniform double mjc:option:ccd_tolerance = 0.000001 ( displayName = "CCD Tolerance" doc = """Tolerance threshold used for early termination of the convex collision algorithm.""" ) - uniform token mjc:physics:cone = "pyramidal" ( + uniform token mjc:option:cone = "pyramidal" ( allowedTokens = ["pyramidal", "elliptic"] displayName = "Friction Cone Type" doc = "The type of contact friction cone." ) - uniform double mjc:physics:density = 0 ( + uniform double mjc:option:density = 0 ( displayName = "Density" doc = "Density of medium." ) - uniform bool mjc:physics:flag:actuation = 1 ( - displayName = "Actuation Forces Toggle" - doc = "Enables all standard computations related to actuator forces, including actuator dynamics." - ) - uniform bool mjc:physics:flag:autoreset = 1 ( - displayName = "Automatic Simulation Reset Toggle" - doc = "Enables the automatic resetting of the simulation state when numerical issues are detected." - ) - uniform bool mjc:physics:flag:clampctrl = 1 ( - displayName = "Control Input Clamping Toggle" - doc = "Enables the clamping of control inputs to all actuators, according to actuator-specific attributes." - ) - uniform bool mjc:physics:flag:constraint = 1 ( - displayName = "Constraint Solver Toggle" - doc = "Enables constraint solver." - ) - uniform bool mjc:physics:flag:contact = 1 ( - displayName = "Contact Constraints and Collision Detection Toggle" - doc = "Enables collision detection and all standard computations related to contact constraints." - ) - uniform bool mjc:physics:flag:energy = 0 ( - displayName = "Energy Computation Toggle" - doc = "Enables the computation of potential and kinetic energy (mjData.energy[0,1])." - ) - uniform bool mjc:physics:flag:equality = 1 ( - displayName = "Equality Constraints Toggle" - doc = "Enables all standard computations related to equality constraints." - ) - uniform bool mjc:physics:flag:eulerdamp = 1 ( - displayName = "Euler Integrator Damping Toggle" - doc = "Enables implicit integration with respect to joint damping in the Euler integrator." - ) - uniform bool mjc:physics:flag:filterparent = 1 ( - displayName = "Parent-Child Contact Filtering Toggle" - doc = "Enables the filtering of contact pairs where the two geoms belong to a parent and child body." - ) - uniform bool mjc:physics:flag:frictionloss = 1 ( - displayName = "Friction Loss Constraints Toggle" - doc = "Enables all standard computations related to friction loss constraints." - ) - uniform bool mjc:physics:flag:fwdinv = 0 ( - displayName = "Forward/Inverse Dynamics Comparison Toggle" - doc = "Enables the automatic comparison of forward and inverse dynamics." - ) - uniform bool mjc:physics:flag:gravity = 1 ( - displayName = "Gravity Toggle" - doc = "Enables the application of gravitational acceleration as defined in mjOption." - ) - uniform bool mjc:physics:flag:invdiscrete = 0 ( - displayName = "Discrete-Time Inverse Dynamics Toggle" - doc = "Enables discrete-time inverse dynamics with mj_inverse for integrators other than RK4." - ) - uniform bool mjc:physics:flag:island = 0 ( - displayName = "Constraint Island Discovery Toggle" - doc = "Enables the discovery of constraint islands." - ) - uniform bool mjc:physics:flag:limit = 1 ( - displayName = "Joint and Tendon Limit Constraints Toggle" - doc = "Enables all standard computations related to joint and tendon limit constraints." - ) - uniform bool mjc:physics:flag:midphase = 1 ( - displayName = "Mid-Phase Collision Filtering Toggle" - doc = "Enables mid-phase collision filtering using a static AABB bounding volume hierarchy (BVH)." - ) - uniform bool mjc:physics:flag:multiccd = 0 ( - displayName = "Multiple Contact Collision Detection (CCD) Toggle" - doc = "Enables multiple-contact collision detection for geom pairs using a general-purpose convex-convex collider." - ) - uniform bool mjc:physics:flag:nativeccd = 1 ( - displayName = "Native Convex Collision Detection Toggle" - doc = "Enables the native convex collision detection pipeline instead of using the libccd library." - ) - uniform bool mjc:physics:flag:override = 0 ( - displayName = "Contact Override Mechanism Toggle" - doc = "Enables the contact override mechanism." - ) - uniform bool mjc:physics:flag:passive = 1 ( - displayName = "Passive Forces Toggle" - doc = "Enables the simulation of joint and tendon spring-dampers, fluid dynamics forces, and custom passive forces." - ) - uniform bool mjc:physics:flag:refsafe = 1 ( - displayName = "Solver Reference Safety Mechanism Toggle" - doc = "Enables a safety mechanism that prevents instabilities due to solref[0] being too small compared to the simulation timestep." - ) - uniform bool mjc:physics:flag:sensor = 1 ( - displayName = "Sensor Computations Toggle" - doc = "Enables all computations related to sensors." - ) - uniform bool mjc:physics:flag:warmstart = 1 ( - displayName = "Solver Warm-Starting Toggle" - doc = "Enables warm-starting of the constraint solver, using the solution from the previous time step to initialize the iterative optimization." - ) - uniform double mjc:physics:impratio = 1 ( + uniform double mjc:option:impratio = 1 ( displayName = "Impedance Ratio" doc = """Ratio of frictional-to-normal constraint impedance for elliptic friction cones.""" ) - uniform token mjc:physics:integrator = "euler" ( + uniform token mjc:option:integrator = "euler" ( allowedTokens = ["euler", "rk4", "implicit", "implicitfast"] displayName = "Integrator" doc = "Numerical integrator to be used." ) - uniform int mjc:physics:iterations = 100 ( + uniform int mjc:option:iterations = 100 ( displayName = "Solver Iterations" doc = "Maximum number of iterations of the constraint solver." ) - uniform token mjc:physics:jacobian = "auto" ( + uniform token mjc:option:jacobian = "auto" ( allowedTokens = ["auto", "dense", "sparse"] displayName = "Jacobian Type" doc = "The type of constraint Jacobian and matrices computed from it." ) - uniform int mjc:physics:ls_iterations = 50 ( + uniform int mjc:option:ls_iterations = 50 ( displayName = "Linesearch Iterations" doc = """Maximum number of linesearch iterations performed by CG/Newton constraint solvers.""" ) - uniform double mjc:physics:ls_tolerance = 0.01 ( + uniform double mjc:option:ls_tolerance = 0.01 ( displayName = "Linesearch Tolerance" doc = "Tolerance threshold used for early termination of the linesearch algorithm." ) - uniform double3 mjc:physics:magnetic = (0, -0.5, 0) ( + uniform double3 mjc:option:magnetic = (0, -0.5, 0) ( displayName = "Magnetic Flux" doc = "Global magnetic flux." ) - uniform int mjc:physics:noslip_iterations = 0 ( + uniform int mjc:option:noslip_iterations = 0 ( displayName = "Noslip Iterations" doc = "Maximum number of iterations of the Noslip solver." ) - uniform double mjc:physics:noslip_tolerance = 0.000001 ( + uniform double mjc:option:noslip_tolerance = 0.000001 ( displayName = "Noslip Tolerance" doc = "Tolerance threshold used for early termination of the Noslip solver." ) - uniform double[] mjc:physics:o_friction = [1, 1, 0.005, 0.0001, 0.0001] ( + uniform double[] mjc:option:o_friction = [1, 1, 0.005, 0.0001, 0.0001] ( displayName = "Contact Override Friction" doc = """Replaces the friction parameter of all active contact pairs when Contact override is enabled.""" ) - uniform double mjc:physics:o_margin = 0 ( + uniform double mjc:option:o_margin = 0 ( displayName = "Contact Override Margin" doc = """Replaces the margin parameter of all active contact pairs when Contact override is enabled.""" ) - uniform double[] mjc:physics:o_solimp = [0.9, 0.95, 0.001, 0.5, 2] ( + uniform double[] mjc:option:o_solimp = [0.9, 0.95, 0.001, 0.5, 2] ( displayName = "Contact Override SolImp" doc = """Replaces the solimp parameter of all active contact pairs when Contact override is enabled.""" ) - uniform double[] mjc:physics:o_solref = [0.02, 1] ( + uniform double[] mjc:option:o_solref = [0.02, 1] ( displayName = "Contact Override SolRef" doc = """Replaces the solref parameter of all active contact pairs when Contact override is enabled.""" ) - uniform int mjc:physics:sdf_initpoints = 40 ( + uniform int mjc:option:sdf_initpoints = 40 ( displayName = "SDF Initial Points" doc = """Number of starting points used for finding contacts with Signed Distance Field collisions.""" ) - uniform int mjc:physics:sdf_iterations = 10 ( + uniform int mjc:option:sdf_iterations = 10 ( displayName = "SDF Iterations" doc = """Number of iterations used for Signed Distance Field collisions (per initial point).""" ) - uniform token mjc:physics:solver = "newton" ( + uniform token mjc:option:solver = "newton" ( allowedTokens = ["pgs", "cg", "newton"] displayName = "Solver" doc = "Constraint solver algorithm to be used." ) - uniform double mjc:physics:timestep = 0.002 ( + uniform double mjc:option:timestep = 0.002 ( displayName = "Timestep" doc = "Controls the timestep in seconds used by MuJoCo." ) - uniform double mjc:physics:tolerance = 1e-8 ( + uniform double mjc:option:tolerance = 1e-8 ( displayName = "Solver Tolerance" doc = """Tolerance threshold used for early termination of the iterative solver.""" ) - uniform double mjc:physics:viscosity = 0 ( + uniform double mjc:option:viscosity = 0 ( displayName = "Viscosity" doc = "Viscosity of medium." ) - uniform double3 mjc:physics:wind = (0, 0, 0) ( + uniform double3 mjc:option:wind = (0, 0, 0) ( displayName = "Wind Velocity" doc = "Velocity vector of medium (i.e. wind)." ) diff --git a/src/experimental/usd/mjcPhysics/sceneAPI.cpp b/src/experimental/usd/mjcPhysics/sceneAPI.cpp index 0c01a533..7bce5c2d 100644 --- a/src/experimental/usd/mjcPhysics/sceneAPI.cpp +++ b/src/experimental/usd/mjcPhysics/sceneAPI.cpp @@ -75,543 +75,543 @@ const TfType &MjcPhysicsSceneAPI::_GetTfType() const { } UsdAttribute MjcPhysicsSceneAPI::GetTimestepAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsTimestep); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionTimestep); } UsdAttribute MjcPhysicsSceneAPI::CreateTimestepAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsTimestep, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionTimestep, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetApiRateAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsApirate); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionApirate); } UsdAttribute MjcPhysicsSceneAPI::CreateApiRateAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsApirate, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionApirate, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetImpRatioAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsImpratio); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionImpratio); } UsdAttribute MjcPhysicsSceneAPI::CreateImpRatioAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsImpratio, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionImpratio, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetWindAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsWind); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionWind); } UsdAttribute MjcPhysicsSceneAPI::CreateWindAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsWind, SdfValueTypeNames->Double3, + MjcPhysicsTokens->mjcOptionWind, SdfValueTypeNames->Double3, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetMagneticAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsMagnetic); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionMagnetic); } UsdAttribute MjcPhysicsSceneAPI::CreateMagneticAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsMagnetic, SdfValueTypeNames->Double3, + MjcPhysicsTokens->mjcOptionMagnetic, SdfValueTypeNames->Double3, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetDensityAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsDensity); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionDensity); } UsdAttribute MjcPhysicsSceneAPI::CreateDensityAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsDensity, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionDensity, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetViscosityAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsViscosity); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionViscosity); } UsdAttribute MjcPhysicsSceneAPI::CreateViscosityAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsViscosity, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionViscosity, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetOMarginAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsO_margin); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionO_margin); } UsdAttribute MjcPhysicsSceneAPI::CreateOMarginAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsO_margin, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionO_margin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetOSolRefAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsO_solref); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionO_solref); } UsdAttribute MjcPhysicsSceneAPI::CreateOSolRefAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsO_solref, SdfValueTypeNames->DoubleArray, + MjcPhysicsTokens->mjcOptionO_solref, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetOSolImpAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsO_solimp); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionO_solimp); } UsdAttribute MjcPhysicsSceneAPI::CreateOSolImpAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsO_solimp, SdfValueTypeNames->DoubleArray, + MjcPhysicsTokens->mjcOptionO_solimp, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetOFrictionAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsO_friction); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionO_friction); } UsdAttribute MjcPhysicsSceneAPI::CreateOFrictionAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsO_friction, SdfValueTypeNames->DoubleArray, + MjcPhysicsTokens->mjcOptionO_friction, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetIntegratorAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsIntegrator); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionIntegrator); } UsdAttribute MjcPhysicsSceneAPI::CreateIntegratorAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsIntegrator, SdfValueTypeNames->Token, + MjcPhysicsTokens->mjcOptionIntegrator, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetConeAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsCone); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionCone); } UsdAttribute MjcPhysicsSceneAPI::CreateConeAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsCone, SdfValueTypeNames->Token, + MjcPhysicsTokens->mjcOptionCone, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetJacobianAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsJacobian); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionJacobian); } UsdAttribute MjcPhysicsSceneAPI::CreateJacobianAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsJacobian, SdfValueTypeNames->Token, + MjcPhysicsTokens->mjcOptionJacobian, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetSolverAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsSolver); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionSolver); } UsdAttribute MjcPhysicsSceneAPI::CreateSolverAttr(VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsSolver, SdfValueTypeNames->Token, + MjcPhysicsTokens->mjcOptionSolver, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetIterationsAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsIterations); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionIterations); } UsdAttribute MjcPhysicsSceneAPI::CreateIterationsAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsIterations, SdfValueTypeNames->Int, + MjcPhysicsTokens->mjcOptionIterations, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetToleranceAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsTolerance); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionTolerance); } UsdAttribute MjcPhysicsSceneAPI::CreateToleranceAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsTolerance, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionTolerance, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetLSIterationsAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsLs_iterations); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionLs_iterations); } UsdAttribute MjcPhysicsSceneAPI::CreateLSIterationsAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsLs_iterations, SdfValueTypeNames->Int, + MjcPhysicsTokens->mjcOptionLs_iterations, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetLSToleranceAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsLs_tolerance); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionLs_tolerance); } UsdAttribute MjcPhysicsSceneAPI::CreateLSToleranceAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsLs_tolerance, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionLs_tolerance, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetNoslipIterationsAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsNoslip_iterations); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionNoslip_iterations); } UsdAttribute MjcPhysicsSceneAPI::CreateNoslipIterationsAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsNoslip_iterations, SdfValueTypeNames->Int, + MjcPhysicsTokens->mjcOptionNoslip_iterations, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetNoslipToleranceAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsNoslip_tolerance); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionNoslip_tolerance); } UsdAttribute MjcPhysicsSceneAPI::CreateNoslipToleranceAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsNoslip_tolerance, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionNoslip_tolerance, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetCCDIterationsAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsCcd_iterations); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionCcd_iterations); } UsdAttribute MjcPhysicsSceneAPI::CreateCCDIterationsAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsCcd_iterations, SdfValueTypeNames->Int, + MjcPhysicsTokens->mjcOptionCcd_iterations, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetCCDToleranceAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsCcd_tolerance); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionCcd_tolerance); } UsdAttribute MjcPhysicsSceneAPI::CreateCCDToleranceAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsCcd_tolerance, SdfValueTypeNames->Double, + MjcPhysicsTokens->mjcOptionCcd_tolerance, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetSDFIterationsAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsSdf_iterations); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionSdf_iterations); } UsdAttribute MjcPhysicsSceneAPI::CreateSDFIterationsAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsSdf_iterations, SdfValueTypeNames->Int, + MjcPhysicsTokens->mjcOptionSdf_iterations, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetSDFInitPointsAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsSdf_initpoints); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcOptionSdf_initpoints); } UsdAttribute MjcPhysicsSceneAPI::CreateSDFInitPointsAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsSdf_initpoints, SdfValueTypeNames->Int, + MjcPhysicsTokens->mjcOptionSdf_initpoints, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetActuatorGroupDisableAttr() const { return GetPrim().GetAttribute( - MjcPhysicsTokens->mjcPhysicsActuatorgroupdisable); + MjcPhysicsTokens->mjcOptionActuatorgroupdisable); } UsdAttribute MjcPhysicsSceneAPI::CreateActuatorGroupDisableAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsActuatorgroupdisable, + MjcPhysicsTokens->mjcOptionActuatorgroupdisable, SdfValueTypeNames->IntArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetConstraintFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagConstraint); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagConstraint); } UsdAttribute MjcPhysicsSceneAPI::CreateConstraintFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagConstraint, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagConstraint, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetEqualityFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagEquality); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagEquality); } UsdAttribute MjcPhysicsSceneAPI::CreateEqualityFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagEquality, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagEquality, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetFrictionLossFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagFrictionloss); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagFrictionloss); } UsdAttribute MjcPhysicsSceneAPI::CreateFrictionLossFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagFrictionloss, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagFrictionloss, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetLimitFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagLimit); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagLimit); } UsdAttribute MjcPhysicsSceneAPI::CreateLimitFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagLimit, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagLimit, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetContactFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagContact); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagContact); } UsdAttribute MjcPhysicsSceneAPI::CreateContactFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagContact, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagContact, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetPassiveFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagPassive); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagPassive); } UsdAttribute MjcPhysicsSceneAPI::CreatePassiveFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagPassive, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagPassive, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetGravityFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagGravity); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagGravity); } UsdAttribute MjcPhysicsSceneAPI::CreateGravityFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagGravity, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagGravity, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetClampCtrlFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagClampctrl); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagClampctrl); } UsdAttribute MjcPhysicsSceneAPI::CreateClampCtrlFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagClampctrl, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagClampctrl, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetWarmStartFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagWarmstart); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagWarmstart); } UsdAttribute MjcPhysicsSceneAPI::CreateWarmStartFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagWarmstart, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagWarmstart, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetFilterParentFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagFilterparent); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagFilterparent); } UsdAttribute MjcPhysicsSceneAPI::CreateFilterParentFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagFilterparent, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagFilterparent, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetActuationFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagActuation); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagActuation); } UsdAttribute MjcPhysicsSceneAPI::CreateActuationFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagActuation, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagActuation, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetRefSafeFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagRefsafe); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagRefsafe); } UsdAttribute MjcPhysicsSceneAPI::CreateRefSafeFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagRefsafe, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagRefsafe, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetSensorFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagSensor); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagSensor); } UsdAttribute MjcPhysicsSceneAPI::CreateSensorFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagSensor, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagSensor, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetMidPhaseFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagMidphase); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagMidphase); } UsdAttribute MjcPhysicsSceneAPI::CreateMidPhaseFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagMidphase, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagMidphase, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetNativeCCDFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagNativeccd); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagNativeccd); } UsdAttribute MjcPhysicsSceneAPI::CreateNativeCCDFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagNativeccd, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagNativeccd, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetEulerDampFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagEulerdamp); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagEulerdamp); } UsdAttribute MjcPhysicsSceneAPI::CreateEulerDampFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagEulerdamp, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagEulerdamp, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetAutoResetFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagAutoreset); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagAutoreset); } UsdAttribute MjcPhysicsSceneAPI::CreateAutoResetFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagAutoreset, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagAutoreset, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetOverrideFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagOverride); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagOverride); } UsdAttribute MjcPhysicsSceneAPI::CreateOverrideFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagOverride, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagOverride, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetEnergyFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagEnergy); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagEnergy); } UsdAttribute MjcPhysicsSceneAPI::CreateEnergyFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagEnergy, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagEnergy, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetFwdinvFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagFwdinv); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagFwdinv); } UsdAttribute MjcPhysicsSceneAPI::CreateFwdinvFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagFwdinv, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagFwdinv, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetInvDiscreteFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagInvdiscrete); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagInvdiscrete); } UsdAttribute MjcPhysicsSceneAPI::CreateInvDiscreteFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagInvdiscrete, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagInvdiscrete, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetMultiCCDFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagMulticcd); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagMulticcd); } UsdAttribute MjcPhysicsSceneAPI::CreateMultiCCDFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagMulticcd, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagMulticcd, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } UsdAttribute MjcPhysicsSceneAPI::GetIslandFlagAttr() const { - return GetPrim().GetAttribute(MjcPhysicsTokens->mjcPhysicsFlagIsland); + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcFlagIsland); } UsdAttribute MjcPhysicsSceneAPI::CreateIslandFlagAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( - MjcPhysicsTokens->mjcPhysicsFlagIsland, SdfValueTypeNames->Bool, + MjcPhysicsTokens->mjcFlagIsland, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } @@ -630,55 +630,55 @@ static inline TfTokenVector _ConcatenateAttributeNames( const TfTokenVector &MjcPhysicsSceneAPI::GetSchemaAttributeNames( bool includeInherited) { static TfTokenVector localNames = { - MjcPhysicsTokens->mjcPhysicsTimestep, - MjcPhysicsTokens->mjcPhysicsApirate, - MjcPhysicsTokens->mjcPhysicsImpratio, - MjcPhysicsTokens->mjcPhysicsWind, - MjcPhysicsTokens->mjcPhysicsMagnetic, - MjcPhysicsTokens->mjcPhysicsDensity, - MjcPhysicsTokens->mjcPhysicsViscosity, - MjcPhysicsTokens->mjcPhysicsO_margin, - MjcPhysicsTokens->mjcPhysicsO_solref, - MjcPhysicsTokens->mjcPhysicsO_solimp, - MjcPhysicsTokens->mjcPhysicsO_friction, - MjcPhysicsTokens->mjcPhysicsIntegrator, - MjcPhysicsTokens->mjcPhysicsCone, - MjcPhysicsTokens->mjcPhysicsJacobian, - MjcPhysicsTokens->mjcPhysicsSolver, - MjcPhysicsTokens->mjcPhysicsIterations, - MjcPhysicsTokens->mjcPhysicsTolerance, - MjcPhysicsTokens->mjcPhysicsLs_iterations, - MjcPhysicsTokens->mjcPhysicsLs_tolerance, - MjcPhysicsTokens->mjcPhysicsNoslip_iterations, - MjcPhysicsTokens->mjcPhysicsNoslip_tolerance, - MjcPhysicsTokens->mjcPhysicsCcd_iterations, - MjcPhysicsTokens->mjcPhysicsCcd_tolerance, - MjcPhysicsTokens->mjcPhysicsSdf_iterations, - MjcPhysicsTokens->mjcPhysicsSdf_initpoints, - MjcPhysicsTokens->mjcPhysicsActuatorgroupdisable, - MjcPhysicsTokens->mjcPhysicsFlagConstraint, - MjcPhysicsTokens->mjcPhysicsFlagEquality, - MjcPhysicsTokens->mjcPhysicsFlagFrictionloss, - MjcPhysicsTokens->mjcPhysicsFlagLimit, - MjcPhysicsTokens->mjcPhysicsFlagContact, - MjcPhysicsTokens->mjcPhysicsFlagPassive, - MjcPhysicsTokens->mjcPhysicsFlagGravity, - MjcPhysicsTokens->mjcPhysicsFlagClampctrl, - MjcPhysicsTokens->mjcPhysicsFlagWarmstart, - MjcPhysicsTokens->mjcPhysicsFlagFilterparent, - MjcPhysicsTokens->mjcPhysicsFlagActuation, - MjcPhysicsTokens->mjcPhysicsFlagRefsafe, - MjcPhysicsTokens->mjcPhysicsFlagSensor, - MjcPhysicsTokens->mjcPhysicsFlagMidphase, - MjcPhysicsTokens->mjcPhysicsFlagNativeccd, - MjcPhysicsTokens->mjcPhysicsFlagEulerdamp, - MjcPhysicsTokens->mjcPhysicsFlagAutoreset, - MjcPhysicsTokens->mjcPhysicsFlagOverride, - MjcPhysicsTokens->mjcPhysicsFlagEnergy, - MjcPhysicsTokens->mjcPhysicsFlagFwdinv, - MjcPhysicsTokens->mjcPhysicsFlagInvdiscrete, - MjcPhysicsTokens->mjcPhysicsFlagMulticcd, - MjcPhysicsTokens->mjcPhysicsFlagIsland, + MjcPhysicsTokens->mjcOptionTimestep, + MjcPhysicsTokens->mjcOptionApirate, + MjcPhysicsTokens->mjcOptionImpratio, + MjcPhysicsTokens->mjcOptionWind, + MjcPhysicsTokens->mjcOptionMagnetic, + MjcPhysicsTokens->mjcOptionDensity, + MjcPhysicsTokens->mjcOptionViscosity, + MjcPhysicsTokens->mjcOptionO_margin, + MjcPhysicsTokens->mjcOptionO_solref, + MjcPhysicsTokens->mjcOptionO_solimp, + MjcPhysicsTokens->mjcOptionO_friction, + MjcPhysicsTokens->mjcOptionIntegrator, + MjcPhysicsTokens->mjcOptionCone, + MjcPhysicsTokens->mjcOptionJacobian, + MjcPhysicsTokens->mjcOptionSolver, + MjcPhysicsTokens->mjcOptionIterations, + MjcPhysicsTokens->mjcOptionTolerance, + MjcPhysicsTokens->mjcOptionLs_iterations, + MjcPhysicsTokens->mjcOptionLs_tolerance, + MjcPhysicsTokens->mjcOptionNoslip_iterations, + MjcPhysicsTokens->mjcOptionNoslip_tolerance, + MjcPhysicsTokens->mjcOptionCcd_iterations, + MjcPhysicsTokens->mjcOptionCcd_tolerance, + MjcPhysicsTokens->mjcOptionSdf_iterations, + MjcPhysicsTokens->mjcOptionSdf_initpoints, + MjcPhysicsTokens->mjcOptionActuatorgroupdisable, + MjcPhysicsTokens->mjcFlagConstraint, + MjcPhysicsTokens->mjcFlagEquality, + MjcPhysicsTokens->mjcFlagFrictionloss, + MjcPhysicsTokens->mjcFlagLimit, + MjcPhysicsTokens->mjcFlagContact, + MjcPhysicsTokens->mjcFlagPassive, + MjcPhysicsTokens->mjcFlagGravity, + MjcPhysicsTokens->mjcFlagClampctrl, + MjcPhysicsTokens->mjcFlagWarmstart, + MjcPhysicsTokens->mjcFlagFilterparent, + MjcPhysicsTokens->mjcFlagActuation, + MjcPhysicsTokens->mjcFlagRefsafe, + MjcPhysicsTokens->mjcFlagSensor, + MjcPhysicsTokens->mjcFlagMidphase, + MjcPhysicsTokens->mjcFlagNativeccd, + MjcPhysicsTokens->mjcFlagEulerdamp, + MjcPhysicsTokens->mjcFlagAutoreset, + MjcPhysicsTokens->mjcFlagOverride, + MjcPhysicsTokens->mjcFlagEnergy, + MjcPhysicsTokens->mjcFlagFwdinv, + MjcPhysicsTokens->mjcFlagInvdiscrete, + MjcPhysicsTokens->mjcFlagMulticcd, + MjcPhysicsTokens->mjcFlagIsland, }; static TfTokenVector allNames = _ConcatenateAttributeNames( UsdAPISchemaBase::GetSchemaAttributeNames(true), localNames); diff --git a/src/experimental/usd/mjcPhysics/sceneAPI.h b/src/experimental/usd/mjcPhysics/sceneAPI.h index 4b77202a..2ac745c7 100644 --- a/src/experimental/usd/mjcPhysics/sceneAPI.h +++ b/src/experimental/usd/mjcPhysics/sceneAPI.h @@ -154,7 +154,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:timestep = 0.002` | + /// | Declaration | `uniform double mjc:option:timestep = 0.002` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -179,7 +179,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:apirate = 100` | + /// | Declaration | `uniform double mjc:option:apirate = 100` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -204,7 +204,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:impratio = 1` | + /// | Declaration | `uniform double mjc:option:impratio = 1` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -228,7 +228,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double3 mjc:physics:wind = (0, 0, 0)` | + /// | Declaration | `uniform double3 mjc:option:wind = (0, 0, 0)` | /// | C++ Type | GfVec3d | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double3 | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -252,7 +252,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double3 mjc:physics:magnetic = (0, -0.5, 0)` | + /// | Declaration | `uniform double3 mjc:option:magnetic = (0, -0.5, 0)` | /// | C++ Type | GfVec3d | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double3 | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -276,7 +276,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:density = 0` | + /// | Declaration | `uniform double mjc:option:density = 0` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -300,7 +300,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:viscosity = 0` | + /// | Declaration | `uniform double mjc:option:viscosity = 0` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -325,7 +325,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:o_margin = 0` | + /// | Declaration | `uniform double mjc:option:o_margin = 0` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -350,7 +350,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double[] mjc:physics:o_solref = [0.02, 1]` | + /// | Declaration | `uniform double[] mjc:option:o_solref = [0.02, 1]` | /// | C++ Type | VtArray | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->DoubleArray | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -375,10 +375,10 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double[] mjc:physics:o_solimp = [0.9, 0.95, - /// 0.001, 0.5, 2]` | | C++ Type | VtArray | | \ref Usd_Datatypes "Usd - /// Type" | SdfValueTypeNames->DoubleArray | | \ref SdfVariability - /// "Variability" | SdfVariabilityUniform | + /// | Declaration | `uniform double[] mjc:option:o_solimp = [0.9, 0.95, 0.001, + /// 0.5, 2]` | | C++ Type | VtArray | | \ref Usd_Datatypes "Usd Type" + /// | SdfValueTypeNames->DoubleArray | | \ref SdfVariability "Variability" | + /// SdfVariabilityUniform | MJCPHYSICS_API UsdAttribute GetOSolImpAttr() const; @@ -400,7 +400,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double[] mjc:physics:o_friction = [1, 1, 0.005, + /// | Declaration | `uniform double[] mjc:option:o_friction = [1, 1, 0.005, /// 0.0001, 0.0001]` | | C++ Type | VtArray | | \ref Usd_Datatypes /// "Usd Type" | SdfValueTypeNames->DoubleArray | | \ref SdfVariability /// "Variability" | SdfVariabilityUniform | @@ -424,7 +424,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform token mjc:physics:integrator = "euler"` | + /// | Declaration | `uniform token mjc:option:integrator = "euler"` | /// | C++ Type | TfToken | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -450,7 +450,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform token mjc:physics:cone = "pyramidal"` | + /// | Declaration | `uniform token mjc:option:cone = "pyramidal"` | /// | C++ Type | TfToken | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -475,7 +475,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform token mjc:physics:jacobian = "auto"` | + /// | Declaration | `uniform token mjc:option:jacobian = "auto"` | /// | C++ Type | TfToken | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -500,7 +500,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform token mjc:physics:solver = "newton"` | + /// | Declaration | `uniform token mjc:option:solver = "newton"` | /// | C++ Type | TfToken | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -525,7 +525,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform int mjc:physics:iterations = 100` | + /// | Declaration | `uniform int mjc:option:iterations = 100` | /// | C++ Type | int | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -550,7 +550,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:tolerance = 1e-8` | + /// | Declaration | `uniform double mjc:option:tolerance = 1e-8` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -575,7 +575,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform int mjc:physics:ls_iterations = 50` | + /// | Declaration | `uniform int mjc:option:ls_iterations = 50` | /// | C++ Type | int | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -600,7 +600,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:ls_tolerance = 0.01` | + /// | Declaration | `uniform double mjc:option:ls_tolerance = 0.01` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -624,7 +624,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform int mjc:physics:noslip_iterations = 0` | + /// | Declaration | `uniform int mjc:option:noslip_iterations = 0` | /// | C++ Type | int | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -649,7 +649,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:noslip_tolerance = 0.000001` | + /// | Declaration | `uniform double mjc:option:noslip_tolerance = 0.000001` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -674,7 +674,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform int mjc:physics:ccd_iterations = 50` | + /// | Declaration | `uniform int mjc:option:ccd_iterations = 50` | /// | C++ Type | int | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -699,7 +699,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform double mjc:physics:ccd_tolerance = 0.000001` | + /// | Declaration | `uniform double mjc:option:ccd_tolerance = 0.000001` | /// | C++ Type | double | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -724,7 +724,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform int mjc:physics:sdf_iterations = 10` | + /// | Declaration | `uniform int mjc:option:sdf_iterations = 10` | /// | C++ Type | int | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -749,7 +749,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform int mjc:physics:sdf_initpoints = 40` | + /// | Declaration | `uniform int mjc:option:sdf_initpoints = 40` | /// | C++ Type | int | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -773,7 +773,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform int[] mjc:physics:actuatorgroupdisable` | + /// | Declaration | `uniform int[] mjc:option:actuatorgroupdisable` | /// | C++ Type | VtArray | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->IntArray | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -798,7 +798,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:constraint = 1` | + /// | Declaration | `uniform bool mjc:flag:constraint = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -822,7 +822,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:equality = 1` | + /// | Declaration | `uniform bool mjc:flag:equality = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -846,7 +846,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:frictionloss = 1` | + /// | Declaration | `uniform bool mjc:flag:frictionloss = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -872,7 +872,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:limit = 1` | + /// | Declaration | `uniform bool mjc:flag:limit = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -897,7 +897,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:contact = 1` | + /// | Declaration | `uniform bool mjc:flag:contact = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -922,7 +922,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:passive = 1` | + /// | Declaration | `uniform bool mjc:flag:passive = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -947,7 +947,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:gravity = 1` | + /// | Declaration | `uniform bool mjc:flag:gravity = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -972,7 +972,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:clampctrl = 1` | + /// | Declaration | `uniform bool mjc:flag:clampctrl = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -997,7 +997,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:warmstart = 1` | + /// | Declaration | `uniform bool mjc:flag:warmstart = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1022,7 +1022,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:filterparent = 1` | + /// | Declaration | `uniform bool mjc:flag:filterparent = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1048,7 +1048,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:actuation = 1` | + /// | Declaration | `uniform bool mjc:flag:actuation = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1073,7 +1073,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:refsafe = 1` | + /// | Declaration | `uniform bool mjc:flag:refsafe = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1097,7 +1097,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:sensor = 1` | + /// | Declaration | `uniform bool mjc:flag:sensor = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1122,7 +1122,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:midphase = 1` | + /// | Declaration | `uniform bool mjc:flag:midphase = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1147,7 +1147,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:nativeccd = 1` | + /// | Declaration | `uniform bool mjc:flag:nativeccd = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1172,7 +1172,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:eulerdamp = 1` | + /// | Declaration | `uniform bool mjc:flag:eulerdamp = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1197,7 +1197,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:autoreset = 1` | + /// | Declaration | `uniform bool mjc:flag:autoreset = 1` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1221,7 +1221,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:override = 0` | + /// | Declaration | `uniform bool mjc:flag:override = 0` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1246,7 +1246,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:energy = 0` | + /// | Declaration | `uniform bool mjc:flag:energy = 0` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1270,7 +1270,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:fwdinv = 0` | + /// | Declaration | `uniform bool mjc:flag:fwdinv = 0` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1295,7 +1295,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:invdiscrete = 0` | + /// | Declaration | `uniform bool mjc:flag:invdiscrete = 0` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1321,7 +1321,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:multiccd = 0` | + /// | Declaration | `uniform bool mjc:flag:multiccd = 0` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | @@ -1345,7 +1345,7 @@ class MjcPhysicsSceneAPI : public UsdAPISchemaBase { /// /// | || /// | -- | -- | - /// | Declaration | `uniform bool mjc:physics:flag:island = 0` | + /// | Declaration | `uniform bool mjc:flag:island = 0` | /// | C++ Type | bool | /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | diff --git a/src/experimental/usd/mjcPhysics/schema.usda b/src/experimental/usd/mjcPhysics/schema.usda index 3d416fc2..322a90a4 100644 --- a/src/experimental/usd/mjcPhysics/schema.usda +++ b/src/experimental/usd/mjcPhysics/schema.usda @@ -99,7 +99,7 @@ class "SceneAPI" inherits = ) { - uniform double mjc:physics:timestep = 0.002 ( + uniform double mjc:option:timestep = 0.002 ( customData = { string apiName = "Timestep" } @@ -107,7 +107,7 @@ class "SceneAPI" doc = """Controls the timestep in seconds used by MuJoCo.""" ) - uniform double mjc:physics:apirate = 100 ( + uniform double mjc:option:apirate = 100 ( customData = { string apiName = "ApiRate" } @@ -116,7 +116,7 @@ class "SceneAPI" the update function to be executed.""" ) - uniform double mjc:physics:impratio = 1.0 ( + uniform double mjc:option:impratio = 1.0 ( customData = { string apiName = "ImpRatio" } @@ -125,7 +125,7 @@ class "SceneAPI" friction cones.""" ) - uniform double3 mjc:physics:wind = (0.0, 0.0, 0.0) ( + uniform double3 mjc:option:wind = (0.0, 0.0, 0.0) ( customData = { string apiName = "Wind" } @@ -133,7 +133,7 @@ class "SceneAPI" doc = """Velocity vector of medium (i.e. wind).""" ) - uniform double3 mjc:physics:magnetic = (0.0, -0.5, 0.0) ( + uniform double3 mjc:option:magnetic = (0.0, -0.5, 0.0) ( customData = { string apiName = "Magnetic" } @@ -141,7 +141,7 @@ class "SceneAPI" doc = """Global magnetic flux.""" ) - uniform double mjc:physics:density = 0.0 ( + uniform double mjc:option:density = 0.0 ( customData = { string apiName = "Density" } @@ -149,7 +149,7 @@ class "SceneAPI" doc = """Density of medium.""" ) - uniform double mjc:physics:viscosity = 0.0 ( + uniform double mjc:option:viscosity = 0.0 ( customData = { string apiName = "Viscosity" } @@ -157,7 +157,7 @@ class "SceneAPI" doc = """Viscosity of medium.""" ) - uniform double mjc:physics:o_margin = 0.0 ( + uniform double mjc:option:o_margin = 0.0 ( customData = { string apiName = "OMargin" } @@ -166,7 +166,7 @@ class "SceneAPI" Contact override is enabled.""" ) - uniform double[] mjc:physics:o_solref = [0.02, 1.0] ( + uniform double[] mjc:option:o_solref = [0.02, 1.0] ( customData = { string apiName = "OSolRef" } @@ -175,7 +175,7 @@ class "SceneAPI" Contact override is enabled.""" ) - uniform double[] mjc:physics:o_solimp = [0.9, 0.95, 0.001, 0.5, 2.0] ( + uniform double[] mjc:option:o_solimp = [0.9, 0.95, 0.001, 0.5, 2.0] ( customData = { string apiName = "OSolImp" } @@ -184,7 +184,7 @@ class "SceneAPI" Contact override is enabled.""" ) - uniform double[] mjc:physics:o_friction = [1.0, 1.0, 0.005, 0.0001, 0.0001] ( + uniform double[] mjc:option:o_friction = [1.0, 1.0, 0.005, 0.0001, 0.0001] ( customData = { string apiName = "OFriction" } @@ -193,7 +193,7 @@ class "SceneAPI" Contact override is enabled.""" ) - uniform token mjc:physics:integrator = "euler" ( + uniform token mjc:option:integrator = "euler" ( allowedTokens = ["euler", "rk4", "implicit", "implicitfast"] customData = { string apiName = "Integrator" @@ -202,7 +202,7 @@ class "SceneAPI" doc = """Numerical integrator to be used.""" ) - uniform token mjc:physics:cone = "pyramidal" ( + uniform token mjc:option:cone = "pyramidal" ( allowedTokens = ["pyramidal", "elliptic"] customData = { string apiName = "Cone" @@ -211,7 +211,7 @@ class "SceneAPI" doc = """The type of contact friction cone.""" ) - uniform token mjc:physics:jacobian = "auto" ( + uniform token mjc:option:jacobian = "auto" ( allowedTokens = ["auto", "dense", "sparse"] customData = { string apiName = "Jacobian" @@ -220,7 +220,7 @@ class "SceneAPI" doc = """The type of constraint Jacobian and matrices computed from it.""" ) - uniform token mjc:physics:solver = "newton" ( + uniform token mjc:option:solver = "newton" ( allowedTokens = ["pgs", "cg", "newton"] customData = { string apiName = "Solver" @@ -229,7 +229,7 @@ class "SceneAPI" doc = """Constraint solver algorithm to be used.""" ) - uniform int mjc:physics:iterations = 100 ( + uniform int mjc:option:iterations = 100 ( customData = { string apiName = "Iterations" } @@ -237,7 +237,7 @@ class "SceneAPI" doc = """Maximum number of iterations of the constraint solver.""" ) - uniform double mjc:physics:tolerance = 1e-08 ( + uniform double mjc:option:tolerance = 1e-08 ( customData = { string apiName = "Tolerance" } @@ -246,7 +246,7 @@ class "SceneAPI" solver.""" ) - uniform int mjc:physics:ls_iterations = 50 ( + uniform int mjc:option:ls_iterations = 50 ( customData = { string apiName = "LSIterations" } @@ -255,7 +255,7 @@ class "SceneAPI" constraint solvers.""" ) - uniform double mjc:physics:ls_tolerance = 0.01 ( + uniform double mjc:option:ls_tolerance = 0.01 ( customData = { string apiName = "LSTolerance" } @@ -263,7 +263,7 @@ class "SceneAPI" doc = """Tolerance threshold used for early termination of the linesearch algorithm.""" ) - uniform int mjc:physics:noslip_iterations = 0 ( + uniform int mjc:option:noslip_iterations = 0 ( customData = { string apiName = "NoslipIterations" } @@ -271,7 +271,7 @@ class "SceneAPI" doc = """Maximum number of iterations of the Noslip solver.""" ) - uniform double mjc:physics:noslip_tolerance = 1e-06 ( + uniform double mjc:option:noslip_tolerance = 1e-06 ( customData = { string apiName = "NoslipTolerance" } @@ -279,7 +279,7 @@ class "SceneAPI" doc = """Tolerance threshold used for early termination of the Noslip solver.""" ) - uniform int mjc:physics:ccd_iterations = 50 ( + uniform int mjc:option:ccd_iterations = 50 ( customData = { string apiName = "CCDIterations" } @@ -287,7 +287,7 @@ class "SceneAPI" doc = """Maximum number of iterations of the algorithm used for convex collisions.""" ) - uniform double mjc:physics:ccd_tolerance = 1e-06 ( + uniform double mjc:option:ccd_tolerance = 1e-06 ( customData = { string apiName = "CCDTolerance" } @@ -296,7 +296,7 @@ class "SceneAPI" collision algorithm.""" ) - uniform int mjc:physics:sdf_iterations = 10 ( + uniform int mjc:option:sdf_iterations = 10 ( customData = { string apiName = "SDFIterations" } @@ -305,7 +305,7 @@ class "SceneAPI" (per initial point).""" ) - uniform int mjc:physics:sdf_initpoints = 40 ( + uniform int mjc:option:sdf_initpoints = 40 ( customData = { string apiName = "SDFInitPoints" } @@ -314,7 +314,7 @@ class "SceneAPI" Distance Field collisions.""" ) - uniform int[] mjc:physics:actuatorgroupdisable ( + uniform int[] mjc:option:actuatorgroupdisable ( customData = { string apiName = "ActuatorGroupDisable" } @@ -322,7 +322,7 @@ class "SceneAPI" doc = """List of actuator groups to disable.""" ) - uniform bool mjc:physics:flag:constraint = True ( + uniform bool mjc:flag:constraint = True ( customData = { string apiName = "ConstraintFlag" } @@ -330,7 +330,7 @@ class "SceneAPI" doc = """Enables constraint solver.""" ) - uniform bool mjc:physics:flag:equality = True ( + uniform bool mjc:flag:equality = True ( customData = { string apiName = "EqualityFlag" } @@ -338,7 +338,7 @@ class "SceneAPI" doc = """Enables all standard computations related to equality constraints.""" ) - uniform bool mjc:physics:flag:frictionloss = True ( + uniform bool mjc:flag:frictionloss = True ( customData = { string apiName = "FrictionLossFlag" } @@ -346,7 +346,7 @@ class "SceneAPI" doc = """Enables all standard computations related to friction loss constraints.""" ) - uniform bool mjc:physics:flag:limit = True ( + uniform bool mjc:flag:limit = True ( customData = { string apiName = "LimitFlag" } @@ -354,7 +354,7 @@ class "SceneAPI" doc = """Enables all standard computations related to joint and tendon limit constraints.""" ) - uniform bool mjc:physics:flag:contact = True ( + uniform bool mjc:flag:contact = True ( customData = { string apiName = "ContactFlag" } @@ -362,7 +362,7 @@ class "SceneAPI" doc = """Enables collision detection and all standard computations related to contact constraints.""" ) - uniform bool mjc:physics:flag:passive = True ( + uniform bool mjc:flag:passive = True ( customData = { string apiName = "PassiveFlag" } @@ -370,7 +370,7 @@ class "SceneAPI" doc = """Enables the simulation of joint and tendon spring-dampers, fluid dynamics forces, and custom passive forces.""" ) - uniform bool mjc:physics:flag:gravity = True ( + uniform bool mjc:flag:gravity = True ( customData = { string apiName = "GravityFlag" } @@ -378,7 +378,7 @@ class "SceneAPI" doc = """Enables the application of gravitational acceleration as defined in mjOption.""" ) - uniform bool mjc:physics:flag:clampctrl = True ( + uniform bool mjc:flag:clampctrl = True ( customData = { string apiName = "ClampCtrlFlag" } @@ -386,7 +386,7 @@ class "SceneAPI" doc = """Enables the clamping of control inputs to all actuators, according to actuator-specific attributes.""" ) - uniform bool mjc:physics:flag:warmstart = True ( + uniform bool mjc:flag:warmstart = True ( customData = { string apiName = "WarmStartFlag" } @@ -394,7 +394,7 @@ class "SceneAPI" doc = """Enables warm-starting of the constraint solver, using the solution from the previous time step to initialize the iterative optimization.""" ) - uniform bool mjc:physics:flag:filterparent = True ( + uniform bool mjc:flag:filterparent = True ( customData = { string apiName = "FilterParentFlag" } @@ -402,7 +402,7 @@ class "SceneAPI" doc = """Enables the filtering of contact pairs where the two geoms belong to a parent and child body.""" ) - uniform bool mjc:physics:flag:actuation = True ( + uniform bool mjc:flag:actuation = True ( customData = { string apiName = "ActuationFlag" } @@ -410,7 +410,7 @@ class "SceneAPI" doc = """Enables all standard computations related to actuator forces, including actuator dynamics.""" ) - uniform bool mjc:physics:flag:refsafe = True ( + uniform bool mjc:flag:refsafe = True ( customData = { string apiName = "RefSafeFlag" } @@ -418,7 +418,7 @@ class "SceneAPI" doc = """Enables a safety mechanism that prevents instabilities due to solref[0] being too small compared to the simulation timestep.""" ) - uniform bool mjc:physics:flag:sensor = True ( + uniform bool mjc:flag:sensor = True ( customData = { string apiName = "SensorFlag" } @@ -426,7 +426,7 @@ class "SceneAPI" doc = """Enables all computations related to sensors.""" ) - uniform bool mjc:physics:flag:midphase = True ( + uniform bool mjc:flag:midphase = True ( customData = { string apiName = "MidPhaseFlag" } @@ -434,7 +434,7 @@ class "SceneAPI" doc = """Enables mid-phase collision filtering using a static AABB bounding volume hierarchy (BVH).""" ) - uniform bool mjc:physics:flag:nativeccd = True ( + uniform bool mjc:flag:nativeccd = True ( customData = { string apiName = "NativeCCDFlag" } @@ -442,7 +442,7 @@ class "SceneAPI" doc = """Enables the native convex collision detection pipeline instead of using the libccd library.""" ) - uniform bool mjc:physics:flag:eulerdamp = True ( + uniform bool mjc:flag:eulerdamp = True ( customData = { string apiName = "EulerDampFlag" } @@ -450,7 +450,7 @@ class "SceneAPI" doc = """Enables implicit integration with respect to joint damping in the Euler integrator.""" ) - uniform bool mjc:physics:flag:autoreset = True ( + uniform bool mjc:flag:autoreset = True ( customData = { string apiName = "AutoResetFlag" } @@ -458,7 +458,7 @@ class "SceneAPI" doc = """Enables the automatic resetting of the simulation state when numerical issues are detected.""" ) - uniform bool mjc:physics:flag:override = False ( + uniform bool mjc:flag:override = False ( customData = { string apiName = "OverrideFlag" } @@ -466,7 +466,7 @@ class "SceneAPI" doc = """Enables the contact override mechanism.""" ) - uniform bool mjc:physics:flag:energy = False ( + uniform bool mjc:flag:energy = False ( customData = { string apiName = "EnergyFlag" } @@ -474,7 +474,7 @@ class "SceneAPI" doc = """Enables the computation of potential and kinetic energy (mjData.energy[0,1]).""" ) - uniform bool mjc:physics:flag:fwdinv = False ( + uniform bool mjc:flag:fwdinv = False ( customData = { string apiName = "FwdinvFlag" } @@ -482,7 +482,7 @@ class "SceneAPI" doc = """Enables the automatic comparison of forward and inverse dynamics.""" ) - uniform bool mjc:physics:flag:invdiscrete = False ( + uniform bool mjc:flag:invdiscrete = False ( customData = { string apiName = "InvDiscreteFlag" } @@ -490,7 +490,7 @@ class "SceneAPI" doc = """Enables discrete-time inverse dynamics with mj_inverse for integrators other than RK4.""" ) - uniform bool mjc:physics:flag:multiccd = False ( + uniform bool mjc:flag:multiccd = False ( customData = { string apiName = "MultiCCDFlag" } @@ -498,7 +498,7 @@ class "SceneAPI" doc = """Enables multiple-contact collision detection for geom pairs using a general-purpose convex-convex collider.""" ) - uniform bool mjc:physics:flag:island = False ( + uniform bool mjc:flag:island = False ( customData = { string apiName = "IslandFlag" } diff --git a/src/experimental/usd/mjcPhysics/tokens.cpp b/src/experimental/usd/mjcPhysics/tokens.cpp index 7b1868f8..2cc35a98 100644 --- a/src/experimental/usd/mjcPhysics/tokens.cpp +++ b/src/experimental/usd/mjcPhysics/tokens.cpp @@ -24,62 +24,58 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() euler("euler", TfToken::Immortal), implicit("implicit", TfToken::Immortal), implicitfast("implicitfast", TfToken::Immortal), - mjcPhysicsActuatorgroupdisable("mjc:physics:actuatorgroupdisable", - TfToken::Immortal), - mjcPhysicsApirate("mjc:physics:apirate", TfToken::Immortal), - mjcPhysicsCcd_iterations("mjc:physics:ccd_iterations", TfToken::Immortal), - mjcPhysicsCcd_tolerance("mjc:physics:ccd_tolerance", TfToken::Immortal), - mjcPhysicsCone("mjc:physics:cone", TfToken::Immortal), - mjcPhysicsDensity("mjc:physics:density", TfToken::Immortal), - mjcPhysicsFlagActuation("mjc:physics:flag:actuation", TfToken::Immortal), - mjcPhysicsFlagAutoreset("mjc:physics:flag:autoreset", TfToken::Immortal), - mjcPhysicsFlagClampctrl("mjc:physics:flag:clampctrl", TfToken::Immortal), - mjcPhysicsFlagConstraint("mjc:physics:flag:constraint", - TfToken::Immortal), - mjcPhysicsFlagContact("mjc:physics:flag:contact", TfToken::Immortal), - mjcPhysicsFlagEnergy("mjc:physics:flag:energy", TfToken::Immortal), - mjcPhysicsFlagEquality("mjc:physics:flag:equality", TfToken::Immortal), - mjcPhysicsFlagEulerdamp("mjc:physics:flag:eulerdamp", TfToken::Immortal), - mjcPhysicsFlagFilterparent("mjc:physics:flag:filterparent", + mjcFlagActuation("mjc:flag:actuation", TfToken::Immortal), + mjcFlagAutoreset("mjc:flag:autoreset", TfToken::Immortal), + mjcFlagClampctrl("mjc:flag:clampctrl", TfToken::Immortal), + mjcFlagConstraint("mjc:flag:constraint", TfToken::Immortal), + mjcFlagContact("mjc:flag:contact", TfToken::Immortal), + mjcFlagEnergy("mjc:flag:energy", TfToken::Immortal), + mjcFlagEquality("mjc:flag:equality", TfToken::Immortal), + mjcFlagEulerdamp("mjc:flag:eulerdamp", TfToken::Immortal), + mjcFlagFilterparent("mjc:flag:filterparent", TfToken::Immortal), + mjcFlagFrictionloss("mjc:flag:frictionloss", TfToken::Immortal), + mjcFlagFwdinv("mjc:flag:fwdinv", TfToken::Immortal), + mjcFlagGravity("mjc:flag:gravity", TfToken::Immortal), + mjcFlagInvdiscrete("mjc:flag:invdiscrete", TfToken::Immortal), + mjcFlagIsland("mjc:flag:island", TfToken::Immortal), + mjcFlagLimit("mjc:flag:limit", TfToken::Immortal), + mjcFlagMidphase("mjc:flag:midphase", TfToken::Immortal), + mjcFlagMulticcd("mjc:flag:multiccd", TfToken::Immortal), + mjcFlagNativeccd("mjc:flag:nativeccd", TfToken::Immortal), + mjcFlagOverride("mjc:flag:override", TfToken::Immortal), + mjcFlagPassive("mjc:flag:passive", TfToken::Immortal), + mjcFlagRefsafe("mjc:flag:refsafe", TfToken::Immortal), + mjcFlagSensor("mjc:flag:sensor", TfToken::Immortal), + mjcFlagWarmstart("mjc:flag:warmstart", TfToken::Immortal), + mjcOptionActuatorgroupdisable("mjc:option:actuatorgroupdisable", + TfToken::Immortal), + mjcOptionApirate("mjc:option:apirate", TfToken::Immortal), + mjcOptionCcd_iterations("mjc:option:ccd_iterations", TfToken::Immortal), + mjcOptionCcd_tolerance("mjc:option:ccd_tolerance", TfToken::Immortal), + mjcOptionCone("mjc:option:cone", TfToken::Immortal), + mjcOptionDensity("mjc:option:density", TfToken::Immortal), + mjcOptionImpratio("mjc:option:impratio", TfToken::Immortal), + mjcOptionIntegrator("mjc:option:integrator", TfToken::Immortal), + mjcOptionIterations("mjc:option:iterations", TfToken::Immortal), + mjcOptionJacobian("mjc:option:jacobian", TfToken::Immortal), + mjcOptionLs_iterations("mjc:option:ls_iterations", TfToken::Immortal), + mjcOptionLs_tolerance("mjc:option:ls_tolerance", TfToken::Immortal), + mjcOptionMagnetic("mjc:option:magnetic", TfToken::Immortal), + mjcOptionNoslip_iterations("mjc:option:noslip_iterations", TfToken::Immortal), - mjcPhysicsFlagFrictionloss("mjc:physics:flag:frictionloss", - TfToken::Immortal), - mjcPhysicsFlagFwdinv("mjc:physics:flag:fwdinv", TfToken::Immortal), - mjcPhysicsFlagGravity("mjc:physics:flag:gravity", TfToken::Immortal), - mjcPhysicsFlagInvdiscrete("mjc:physics:flag:invdiscrete", + mjcOptionNoslip_tolerance("mjc:option:noslip_tolerance", TfToken::Immortal), - mjcPhysicsFlagIsland("mjc:physics:flag:island", TfToken::Immortal), - mjcPhysicsFlagLimit("mjc:physics:flag:limit", TfToken::Immortal), - mjcPhysicsFlagMidphase("mjc:physics:flag:midphase", TfToken::Immortal), - mjcPhysicsFlagMulticcd("mjc:physics:flag:multiccd", TfToken::Immortal), - mjcPhysicsFlagNativeccd("mjc:physics:flag:nativeccd", TfToken::Immortal), - mjcPhysicsFlagOverride("mjc:physics:flag:override", TfToken::Immortal), - mjcPhysicsFlagPassive("mjc:physics:flag:passive", TfToken::Immortal), - mjcPhysicsFlagRefsafe("mjc:physics:flag:refsafe", TfToken::Immortal), - mjcPhysicsFlagSensor("mjc:physics:flag:sensor", TfToken::Immortal), - mjcPhysicsFlagWarmstart("mjc:physics:flag:warmstart", TfToken::Immortal), - mjcPhysicsImpratio("mjc:physics:impratio", TfToken::Immortal), - mjcPhysicsIntegrator("mjc:physics:integrator", TfToken::Immortal), - mjcPhysicsIterations("mjc:physics:iterations", TfToken::Immortal), - mjcPhysicsJacobian("mjc:physics:jacobian", TfToken::Immortal), - mjcPhysicsLs_iterations("mjc:physics:ls_iterations", TfToken::Immortal), - mjcPhysicsLs_tolerance("mjc:physics:ls_tolerance", TfToken::Immortal), - mjcPhysicsMagnetic("mjc:physics:magnetic", TfToken::Immortal), - mjcPhysicsNoslip_iterations("mjc:physics:noslip_iterations", - TfToken::Immortal), - mjcPhysicsNoslip_tolerance("mjc:physics:noslip_tolerance", - TfToken::Immortal), - mjcPhysicsO_friction("mjc:physics:o_friction", TfToken::Immortal), - mjcPhysicsO_margin("mjc:physics:o_margin", TfToken::Immortal), - mjcPhysicsO_solimp("mjc:physics:o_solimp", TfToken::Immortal), - mjcPhysicsO_solref("mjc:physics:o_solref", TfToken::Immortal), - mjcPhysicsSdf_initpoints("mjc:physics:sdf_initpoints", TfToken::Immortal), - mjcPhysicsSdf_iterations("mjc:physics:sdf_iterations", TfToken::Immortal), - mjcPhysicsSolver("mjc:physics:solver", TfToken::Immortal), - mjcPhysicsTimestep("mjc:physics:timestep", TfToken::Immortal), - mjcPhysicsTolerance("mjc:physics:tolerance", TfToken::Immortal), - mjcPhysicsViscosity("mjc:physics:viscosity", TfToken::Immortal), - mjcPhysicsWind("mjc:physics:wind", TfToken::Immortal), + mjcOptionO_friction("mjc:option:o_friction", TfToken::Immortal), + mjcOptionO_margin("mjc:option:o_margin", TfToken::Immortal), + mjcOptionO_solimp("mjc:option:o_solimp", TfToken::Immortal), + mjcOptionO_solref("mjc:option:o_solref", TfToken::Immortal), + mjcOptionSdf_initpoints("mjc:option:sdf_initpoints", TfToken::Immortal), + mjcOptionSdf_iterations("mjc:option:sdf_iterations", TfToken::Immortal), + mjcOptionSolver("mjc:option:solver", TfToken::Immortal), + mjcOptionTimestep("mjc:option:timestep", TfToken::Immortal), + mjcOptionTolerance("mjc:option:tolerance", TfToken::Immortal), + mjcOptionViscosity("mjc:option:viscosity", TfToken::Immortal), + mjcOptionWind("mjc:option:wind", TfToken::Immortal), newton("newton", TfToken::Immortal), pgs("pgs", TfToken::Immortal), pyramidal("pyramidal", TfToken::Immortal), @@ -94,55 +90,55 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() euler, implicit, implicitfast, - mjcPhysicsActuatorgroupdisable, - mjcPhysicsApirate, - mjcPhysicsCcd_iterations, - mjcPhysicsCcd_tolerance, - mjcPhysicsCone, - mjcPhysicsDensity, - mjcPhysicsFlagActuation, - mjcPhysicsFlagAutoreset, - mjcPhysicsFlagClampctrl, - mjcPhysicsFlagConstraint, - mjcPhysicsFlagContact, - mjcPhysicsFlagEnergy, - mjcPhysicsFlagEquality, - mjcPhysicsFlagEulerdamp, - mjcPhysicsFlagFilterparent, - mjcPhysicsFlagFrictionloss, - mjcPhysicsFlagFwdinv, - mjcPhysicsFlagGravity, - mjcPhysicsFlagInvdiscrete, - mjcPhysicsFlagIsland, - mjcPhysicsFlagLimit, - mjcPhysicsFlagMidphase, - mjcPhysicsFlagMulticcd, - mjcPhysicsFlagNativeccd, - mjcPhysicsFlagOverride, - mjcPhysicsFlagPassive, - mjcPhysicsFlagRefsafe, - mjcPhysicsFlagSensor, - mjcPhysicsFlagWarmstart, - mjcPhysicsImpratio, - mjcPhysicsIntegrator, - mjcPhysicsIterations, - mjcPhysicsJacobian, - mjcPhysicsLs_iterations, - mjcPhysicsLs_tolerance, - mjcPhysicsMagnetic, - mjcPhysicsNoslip_iterations, - mjcPhysicsNoslip_tolerance, - mjcPhysicsO_friction, - mjcPhysicsO_margin, - mjcPhysicsO_solimp, - mjcPhysicsO_solref, - mjcPhysicsSdf_initpoints, - mjcPhysicsSdf_iterations, - mjcPhysicsSolver, - mjcPhysicsTimestep, - mjcPhysicsTolerance, - mjcPhysicsViscosity, - mjcPhysicsWind, + mjcFlagActuation, + mjcFlagAutoreset, + mjcFlagClampctrl, + mjcFlagConstraint, + mjcFlagContact, + mjcFlagEnergy, + mjcFlagEquality, + mjcFlagEulerdamp, + mjcFlagFilterparent, + mjcFlagFrictionloss, + mjcFlagFwdinv, + mjcFlagGravity, + mjcFlagInvdiscrete, + mjcFlagIsland, + mjcFlagLimit, + mjcFlagMidphase, + mjcFlagMulticcd, + mjcFlagNativeccd, + mjcFlagOverride, + mjcFlagPassive, + mjcFlagRefsafe, + mjcFlagSensor, + mjcFlagWarmstart, + mjcOptionActuatorgroupdisable, + mjcOptionApirate, + mjcOptionCcd_iterations, + mjcOptionCcd_tolerance, + mjcOptionCone, + mjcOptionDensity, + mjcOptionImpratio, + mjcOptionIntegrator, + mjcOptionIterations, + mjcOptionJacobian, + mjcOptionLs_iterations, + mjcOptionLs_tolerance, + mjcOptionMagnetic, + mjcOptionNoslip_iterations, + mjcOptionNoslip_tolerance, + mjcOptionO_friction, + mjcOptionO_margin, + mjcOptionO_solimp, + mjcOptionO_solref, + mjcOptionSdf_initpoints, + mjcOptionSdf_iterations, + mjcOptionSolver, + mjcOptionTimestep, + mjcOptionTolerance, + mjcOptionViscosity, + mjcOptionWind, newton, pgs, pyramidal, diff --git a/src/experimental/usd/mjcPhysics/tokens.h b/src/experimental/usd/mjcPhysics/tokens.h index 50239a66..7bdf56f2 100644 --- a/src/experimental/usd/mjcPhysics/tokens.h +++ b/src/experimental/usd/mjcPhysics/tokens.h @@ -88,202 +88,202 @@ struct MjcPhysicsTokensType { /// Possible value for MjcPhysicsSceneAPI::GetIntegratorAttr(), This token /// represents the implicitfast numerical integrator. const TfToken implicitfast; - /// \brief "mjc:physics:actuatorgroupdisable" + /// \brief "mjc:flag:actuation" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsActuatorgroupdisable; - /// \brief "mjc:physics:apirate" + const TfToken mjcFlagActuation; + /// \brief "mjc:flag:autoreset" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsApirate; - /// \brief "mjc:physics:ccd_iterations" + const TfToken mjcFlagAutoreset; + /// \brief "mjc:flag:clampctrl" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsCcd_iterations; - /// \brief "mjc:physics:ccd_tolerance" + const TfToken mjcFlagClampctrl; + /// \brief "mjc:flag:constraint" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsCcd_tolerance; - /// \brief "mjc:physics:cone" + const TfToken mjcFlagConstraint; + /// \brief "mjc:flag:contact" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsCone; - /// \brief "mjc:physics:density" + const TfToken mjcFlagContact; + /// \brief "mjc:flag:energy" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsDensity; - /// \brief "mjc:physics:flag:actuation" + const TfToken mjcFlagEnergy; + /// \brief "mjc:flag:equality" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagActuation; - /// \brief "mjc:physics:flag:autoreset" + const TfToken mjcFlagEquality; + /// \brief "mjc:flag:eulerdamp" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagAutoreset; - /// \brief "mjc:physics:flag:clampctrl" + const TfToken mjcFlagEulerdamp; + /// \brief "mjc:flag:filterparent" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagClampctrl; - /// \brief "mjc:physics:flag:constraint" + const TfToken mjcFlagFilterparent; + /// \brief "mjc:flag:frictionloss" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagConstraint; - /// \brief "mjc:physics:flag:contact" + const TfToken mjcFlagFrictionloss; + /// \brief "mjc:flag:fwdinv" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagContact; - /// \brief "mjc:physics:flag:energy" + const TfToken mjcFlagFwdinv; + /// \brief "mjc:flag:gravity" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagEnergy; - /// \brief "mjc:physics:flag:equality" + const TfToken mjcFlagGravity; + /// \brief "mjc:flag:invdiscrete" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagEquality; - /// \brief "mjc:physics:flag:eulerdamp" + const TfToken mjcFlagInvdiscrete; + /// \brief "mjc:flag:island" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagEulerdamp; - /// \brief "mjc:physics:flag:filterparent" + const TfToken mjcFlagIsland; + /// \brief "mjc:flag:limit" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagFilterparent; - /// \brief "mjc:physics:flag:frictionloss" + const TfToken mjcFlagLimit; + /// \brief "mjc:flag:midphase" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagFrictionloss; - /// \brief "mjc:physics:flag:fwdinv" + const TfToken mjcFlagMidphase; + /// \brief "mjc:flag:multiccd" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagFwdinv; - /// \brief "mjc:physics:flag:gravity" + const TfToken mjcFlagMulticcd; + /// \brief "mjc:flag:nativeccd" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagGravity; - /// \brief "mjc:physics:flag:invdiscrete" + const TfToken mjcFlagNativeccd; + /// \brief "mjc:flag:override" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagInvdiscrete; - /// \brief "mjc:physics:flag:island" + const TfToken mjcFlagOverride; + /// \brief "mjc:flag:passive" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagIsland; - /// \brief "mjc:physics:flag:limit" + const TfToken mjcFlagPassive; + /// \brief "mjc:flag:refsafe" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagLimit; - /// \brief "mjc:physics:flag:midphase" + const TfToken mjcFlagRefsafe; + /// \brief "mjc:flag:sensor" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagMidphase; - /// \brief "mjc:physics:flag:multiccd" + const TfToken mjcFlagSensor; + /// \brief "mjc:flag:warmstart" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagMulticcd; - /// \brief "mjc:physics:flag:nativeccd" + const TfToken mjcFlagWarmstart; + /// \brief "mjc:option:actuatorgroupdisable" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagNativeccd; - /// \brief "mjc:physics:flag:override" + const TfToken mjcOptionActuatorgroupdisable; + /// \brief "mjc:option:apirate" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagOverride; - /// \brief "mjc:physics:flag:passive" + const TfToken mjcOptionApirate; + /// \brief "mjc:option:ccd_iterations" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagPassive; - /// \brief "mjc:physics:flag:refsafe" + const TfToken mjcOptionCcd_iterations; + /// \brief "mjc:option:ccd_tolerance" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagRefsafe; - /// \brief "mjc:physics:flag:sensor" + const TfToken mjcOptionCcd_tolerance; + /// \brief "mjc:option:cone" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagSensor; - /// \brief "mjc:physics:flag:warmstart" + const TfToken mjcOptionCone; + /// \brief "mjc:option:density" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsFlagWarmstart; - /// \brief "mjc:physics:impratio" + const TfToken mjcOptionDensity; + /// \brief "mjc:option:impratio" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsImpratio; - /// \brief "mjc:physics:integrator" + const TfToken mjcOptionImpratio; + /// \brief "mjc:option:integrator" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsIntegrator; - /// \brief "mjc:physics:iterations" + const TfToken mjcOptionIntegrator; + /// \brief "mjc:option:iterations" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsIterations; - /// \brief "mjc:physics:jacobian" + const TfToken mjcOptionIterations; + /// \brief "mjc:option:jacobian" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsJacobian; - /// \brief "mjc:physics:ls_iterations" + const TfToken mjcOptionJacobian; + /// \brief "mjc:option:ls_iterations" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsLs_iterations; - /// \brief "mjc:physics:ls_tolerance" + const TfToken mjcOptionLs_iterations; + /// \brief "mjc:option:ls_tolerance" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsLs_tolerance; - /// \brief "mjc:physics:magnetic" + const TfToken mjcOptionLs_tolerance; + /// \brief "mjc:option:magnetic" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsMagnetic; - /// \brief "mjc:physics:noslip_iterations" + const TfToken mjcOptionMagnetic; + /// \brief "mjc:option:noslip_iterations" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsNoslip_iterations; - /// \brief "mjc:physics:noslip_tolerance" + const TfToken mjcOptionNoslip_iterations; + /// \brief "mjc:option:noslip_tolerance" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsNoslip_tolerance; - /// \brief "mjc:physics:o_friction" + const TfToken mjcOptionNoslip_tolerance; + /// \brief "mjc:option:o_friction" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsO_friction; - /// \brief "mjc:physics:o_margin" + const TfToken mjcOptionO_friction; + /// \brief "mjc:option:o_margin" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsO_margin; - /// \brief "mjc:physics:o_solimp" + const TfToken mjcOptionO_margin; + /// \brief "mjc:option:o_solimp" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsO_solimp; - /// \brief "mjc:physics:o_solref" + const TfToken mjcOptionO_solimp; + /// \brief "mjc:option:o_solref" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsO_solref; - /// \brief "mjc:physics:sdf_initpoints" + const TfToken mjcOptionO_solref; + /// \brief "mjc:option:sdf_initpoints" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsSdf_initpoints; - /// \brief "mjc:physics:sdf_iterations" + const TfToken mjcOptionSdf_initpoints; + /// \brief "mjc:option:sdf_iterations" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsSdf_iterations; - /// \brief "mjc:physics:solver" + const TfToken mjcOptionSdf_iterations; + /// \brief "mjc:option:solver" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsSolver; - /// \brief "mjc:physics:timestep" + const TfToken mjcOptionSolver; + /// \brief "mjc:option:timestep" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsTimestep; - /// \brief "mjc:physics:tolerance" + const TfToken mjcOptionTimestep; + /// \brief "mjc:option:tolerance" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsTolerance; - /// \brief "mjc:physics:viscosity" + const TfToken mjcOptionTolerance; + /// \brief "mjc:option:viscosity" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsViscosity; - /// \brief "mjc:physics:wind" + const TfToken mjcOptionViscosity; + /// \brief "mjc:option:wind" /// /// MjcPhysicsSceneAPI - const TfToken mjcPhysicsWind; + const TfToken mjcOptionWind; /// \brief "newton" /// /// Fallback value for MjcPhysicsSceneAPI::GetSolverAttr(), This token