Fix namespacing in USD schema.

PiperOrigin-RevId: 759632714
Change-Id: I666ca0e5b7f264f63eae0bbb39f0403654fb1c56

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 (
+    uniform double mjc:option:impratio = 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 (
         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)."
     )

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->mjcOptionTimestep,
-      MjcPhysicsTokens->mjcPhysicsApirate,
+      MjcPhysicsTokens->mjcOptionApirate,
-      MjcPhysicsTokens->mjcPhysicsImpratio,
+      MjcPhysicsTokens->mjcOptionImpratio,
-      MjcPhysicsTokens->mjcPhysicsWind,
+      MjcPhysicsTokens->mjcOptionWind,
-      MjcPhysicsTokens->mjcPhysicsMagnetic,
+      MjcPhysicsTokens->mjcOptionMagnetic,
-      MjcPhysicsTokens->mjcPhysicsDensity,
+      MjcPhysicsTokens->mjcOptionDensity,
-      MjcPhysicsTokens->mjcPhysicsViscosity,
+      MjcPhysicsTokens->mjcOptionViscosity,
-      MjcPhysicsTokens->mjcPhysicsO_margin,
+      MjcPhysicsTokens->mjcOptionO_margin,
-      MjcPhysicsTokens->mjcPhysicsO_solref,
+      MjcPhysicsTokens->mjcOptionO_solref,
-      MjcPhysicsTokens->mjcPhysicsO_solimp,
+      MjcPhysicsTokens->mjcOptionO_solimp,
-      MjcPhysicsTokens->mjcPhysicsO_friction,
+      MjcPhysicsTokens->mjcOptionO_friction,
-      MjcPhysicsTokens->mjcPhysicsIntegrator,
+      MjcPhysicsTokens->mjcOptionIntegrator,
-      MjcPhysicsTokens->mjcPhysicsCone,
+      MjcPhysicsTokens->mjcOptionCone,
-      MjcPhysicsTokens->mjcPhysicsJacobian,
+      MjcPhysicsTokens->mjcOptionJacobian,
-      MjcPhysicsTokens->mjcPhysicsSolver,
+      MjcPhysicsTokens->mjcOptionSolver,
-      MjcPhysicsTokens->mjcPhysicsIterations,
+      MjcPhysicsTokens->mjcOptionIterations,
-      MjcPhysicsTokens->mjcPhysicsTolerance,
+      MjcPhysicsTokens->mjcOptionTolerance,
-      MjcPhysicsTokens->mjcPhysicsLs_iterations,
+      MjcPhysicsTokens->mjcOptionLs_iterations,
-      MjcPhysicsTokens->mjcPhysicsLs_tolerance,
+      MjcPhysicsTokens->mjcOptionLs_tolerance,
-      MjcPhysicsTokens->mjcPhysicsNoslip_iterations,
+      MjcPhysicsTokens->mjcOptionNoslip_iterations,
-      MjcPhysicsTokens->mjcPhysicsNoslip_tolerance,
+      MjcPhysicsTokens->mjcOptionNoslip_tolerance,
-      MjcPhysicsTokens->mjcPhysicsCcd_iterations,
+      MjcPhysicsTokens->mjcOptionCcd_iterations,
-      MjcPhysicsTokens->mjcPhysicsCcd_tolerance,
+      MjcPhysicsTokens->mjcOptionCcd_tolerance,
-      MjcPhysicsTokens->mjcPhysicsSdf_iterations,
+      MjcPhysicsTokens->mjcOptionSdf_iterations,
-      MjcPhysicsTokens->mjcPhysicsSdf_initpoints,
+      MjcPhysicsTokens->mjcOptionSdf_initpoints,
-      MjcPhysicsTokens->mjcPhysicsActuatorgroupdisable,
+      MjcPhysicsTokens->mjcOptionActuatorgroupdisable,
-      MjcPhysicsTokens->mjcPhysicsFlagConstraint,
+      MjcPhysicsTokens->mjcFlagConstraint,
-      MjcPhysicsTokens->mjcPhysicsFlagEquality,
+      MjcPhysicsTokens->mjcFlagEquality,
-      MjcPhysicsTokens->mjcPhysicsFlagFrictionloss,
+      MjcPhysicsTokens->mjcFlagFrictionloss,
-      MjcPhysicsTokens->mjcPhysicsFlagLimit,
+      MjcPhysicsTokens->mjcFlagLimit,
-      MjcPhysicsTokens->mjcPhysicsFlagContact,
+      MjcPhysicsTokens->mjcFlagContact,
-      MjcPhysicsTokens->mjcPhysicsFlagPassive,
+      MjcPhysicsTokens->mjcFlagPassive,
-      MjcPhysicsTokens->mjcPhysicsFlagGravity,
+      MjcPhysicsTokens->mjcFlagGravity,
-      MjcPhysicsTokens->mjcPhysicsFlagClampctrl,
+      MjcPhysicsTokens->mjcFlagClampctrl,
-      MjcPhysicsTokens->mjcPhysicsFlagWarmstart,
+      MjcPhysicsTokens->mjcFlagWarmstart,
-      MjcPhysicsTokens->mjcPhysicsFlagFilterparent,
+      MjcPhysicsTokens->mjcFlagFilterparent,
-      MjcPhysicsTokens->mjcPhysicsFlagActuation,
+      MjcPhysicsTokens->mjcFlagActuation,
-      MjcPhysicsTokens->mjcPhysicsFlagRefsafe,
+      MjcPhysicsTokens->mjcFlagRefsafe,
-      MjcPhysicsTokens->mjcPhysicsFlagSensor,
+      MjcPhysicsTokens->mjcFlagSensor,
-      MjcPhysicsTokens->mjcPhysicsFlagMidphase,
+      MjcPhysicsTokens->mjcFlagMidphase,
-      MjcPhysicsTokens->mjcPhysicsFlagNativeccd,
+      MjcPhysicsTokens->mjcFlagNativeccd,
-      MjcPhysicsTokens->mjcPhysicsFlagEulerdamp,
+      MjcPhysicsTokens->mjcFlagEulerdamp,
-      MjcPhysicsTokens->mjcPhysicsFlagAutoreset,
+      MjcPhysicsTokens->mjcFlagAutoreset,
-      MjcPhysicsTokens->mjcPhysicsFlagOverride,
+      MjcPhysicsTokens->mjcFlagOverride,
-      MjcPhysicsTokens->mjcPhysicsFlagEnergy,
+      MjcPhysicsTokens->mjcFlagEnergy,
-      MjcPhysicsTokens->mjcPhysicsFlagFwdinv,
+      MjcPhysicsTokens->mjcFlagFwdinv,
-      MjcPhysicsTokens->mjcPhysicsFlagInvdiscrete,
+      MjcPhysicsTokens->mjcFlagInvdiscrete,
-      MjcPhysicsTokens->mjcPhysicsFlagMulticcd,
+      MjcPhysicsTokens->mjcFlagMulticcd,
-      MjcPhysicsTokens->mjcPhysicsFlagIsland,
+      MjcPhysicsTokens->mjcFlagIsland,
   };
   static TfTokenVector allNames = _ConcatenateAttributeNames(
       UsdAPISchemaBase::GetSchemaAttributeNames(true), localNames);

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<double> |
   /// | \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,
+  /// | Declaration | `uniform double[] mjc:option:o_solimp = [0.9, 0.95, 0.001,
-  /// 0.001, 0.5, 2]` | | C++ Type | VtArray<double> | | \ref Usd_Datatypes "Usd
+  /// 0.5, 2]` | | C++ Type | VtArray<double> | | \ref Usd_Datatypes "Usd Type"
-  /// Type" | SdfValueTypeNames->DoubleArray | | \ref SdfVariability
+  /// | SdfValueTypeNames->DoubleArray | | \ref SdfVariability "Variability" |
-  /// "Variability" | SdfVariabilityUniform |
+  /// 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<double> | | \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<int> |
   /// | \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 |

src/experimental/usd/mjcPhysics/schema.usda

@@ -99,7 +99,7 @@ class "SceneAPI"
     inherits = </APISchemaBase>
 )
 {
-    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"
         }

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",
+      mjcFlagActuation("mjc:flag:actuation", TfToken::Immortal),
-                                     TfToken::Immortal),
+      mjcFlagAutoreset("mjc:flag:autoreset", TfToken::Immortal),
-      mjcPhysicsApirate("mjc:physics:apirate", TfToken::Immortal),
+      mjcFlagClampctrl("mjc:flag:clampctrl", TfToken::Immortal),
-      mjcPhysicsCcd_iterations("mjc:physics:ccd_iterations", TfToken::Immortal),
+      mjcFlagConstraint("mjc:flag:constraint", TfToken::Immortal),
-      mjcPhysicsCcd_tolerance("mjc:physics:ccd_tolerance", TfToken::Immortal),
+      mjcFlagContact("mjc:flag:contact", TfToken::Immortal),
-      mjcPhysicsCone("mjc:physics:cone", TfToken::Immortal),
+      mjcFlagEnergy("mjc:flag:energy", TfToken::Immortal),
-      mjcPhysicsDensity("mjc:physics:density", TfToken::Immortal),
+      mjcFlagEquality("mjc:flag:equality", TfToken::Immortal),
-      mjcPhysicsFlagActuation("mjc:physics:flag:actuation", TfToken::Immortal),
+      mjcFlagEulerdamp("mjc:flag:eulerdamp", TfToken::Immortal),
-      mjcPhysicsFlagAutoreset("mjc:physics:flag:autoreset", TfToken::Immortal),
+      mjcFlagFilterparent("mjc:flag:filterparent", TfToken::Immortal),
-      mjcPhysicsFlagClampctrl("mjc:physics:flag:clampctrl", TfToken::Immortal),
+      mjcFlagFrictionloss("mjc:flag:frictionloss", TfToken::Immortal),
-      mjcPhysicsFlagConstraint("mjc:physics:flag:constraint",
+      mjcFlagFwdinv("mjc:flag:fwdinv", TfToken::Immortal),
-                               TfToken::Immortal),
+      mjcFlagGravity("mjc:flag:gravity", TfToken::Immortal),
-      mjcPhysicsFlagContact("mjc:physics:flag:contact", TfToken::Immortal),
+      mjcFlagInvdiscrete("mjc:flag:invdiscrete", TfToken::Immortal),
-      mjcPhysicsFlagEnergy("mjc:physics:flag:energy", TfToken::Immortal),
+      mjcFlagIsland("mjc:flag:island", TfToken::Immortal),
-      mjcPhysicsFlagEquality("mjc:physics:flag:equality", TfToken::Immortal),
+      mjcFlagLimit("mjc:flag:limit", TfToken::Immortal),
-      mjcPhysicsFlagEulerdamp("mjc:physics:flag:eulerdamp", TfToken::Immortal),
+      mjcFlagMidphase("mjc:flag:midphase", TfToken::Immortal),
-      mjcPhysicsFlagFilterparent("mjc:physics:flag:filterparent",
+      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",
+      mjcOptionNoslip_tolerance("mjc:option:noslip_tolerance",
-                                 TfToken::Immortal),
-      mjcPhysicsFlagFwdinv("mjc:physics:flag:fwdinv", TfToken::Immortal),
-      mjcPhysicsFlagGravity("mjc:physics:flag:gravity", TfToken::Immortal),
-      mjcPhysicsFlagInvdiscrete("mjc:physics:flag:invdiscrete",
                                 TfToken::Immortal),
-      mjcPhysicsFlagIsland("mjc:physics:flag:island", TfToken::Immortal),
+      mjcOptionO_friction("mjc:option:o_friction", TfToken::Immortal),
-      mjcPhysicsFlagLimit("mjc:physics:flag:limit", TfToken::Immortal),
+      mjcOptionO_margin("mjc:option:o_margin", TfToken::Immortal),
-      mjcPhysicsFlagMidphase("mjc:physics:flag:midphase", TfToken::Immortal),
+      mjcOptionO_solimp("mjc:option:o_solimp", TfToken::Immortal),
-      mjcPhysicsFlagMulticcd("mjc:physics:flag:multiccd", TfToken::Immortal),
+      mjcOptionO_solref("mjc:option:o_solref", TfToken::Immortal),
-      mjcPhysicsFlagNativeccd("mjc:physics:flag:nativeccd", TfToken::Immortal),
+      mjcOptionSdf_initpoints("mjc:option:sdf_initpoints", TfToken::Immortal),
-      mjcPhysicsFlagOverride("mjc:physics:flag:override", TfToken::Immortal),
+      mjcOptionSdf_iterations("mjc:option:sdf_iterations", TfToken::Immortal),
-      mjcPhysicsFlagPassive("mjc:physics:flag:passive", TfToken::Immortal),
+      mjcOptionSolver("mjc:option:solver", TfToken::Immortal),
-      mjcPhysicsFlagRefsafe("mjc:physics:flag:refsafe", TfToken::Immortal),
+      mjcOptionTimestep("mjc:option:timestep", TfToken::Immortal),
-      mjcPhysicsFlagSensor("mjc:physics:flag:sensor", TfToken::Immortal),
+      mjcOptionTolerance("mjc:option:tolerance", TfToken::Immortal),
-      mjcPhysicsFlagWarmstart("mjc:physics:flag:warmstart", TfToken::Immortal),
+      mjcOptionViscosity("mjc:option:viscosity", TfToken::Immortal),
-      mjcPhysicsImpratio("mjc:physics:impratio", TfToken::Immortal),
+      mjcOptionWind("mjc:option:wind", 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),
       newton("newton", TfToken::Immortal),
       pgs("pgs", TfToken::Immortal),
       pyramidal("pyramidal", TfToken::Immortal),
@@ -94,55 +90,55 @@ MjcPhysicsTokensType::MjcPhysicsTokensType()
                  euler,
                  implicit,
                  implicitfast,
-                 mjcPhysicsActuatorgroupdisable,
+                 mjcFlagActuation,
-                 mjcPhysicsApirate,
+                 mjcFlagAutoreset,
-                 mjcPhysicsCcd_iterations,
+                 mjcFlagClampctrl,
-                 mjcPhysicsCcd_tolerance,
+                 mjcFlagConstraint,
-                 mjcPhysicsCone,
+                 mjcFlagContact,
-                 mjcPhysicsDensity,
+                 mjcFlagEnergy,
-                 mjcPhysicsFlagActuation,
+                 mjcFlagEquality,
-                 mjcPhysicsFlagAutoreset,
+                 mjcFlagEulerdamp,
-                 mjcPhysicsFlagClampctrl,
+                 mjcFlagFilterparent,
-                 mjcPhysicsFlagConstraint,
+                 mjcFlagFrictionloss,
-                 mjcPhysicsFlagContact,
+                 mjcFlagFwdinv,
-                 mjcPhysicsFlagEnergy,
+                 mjcFlagGravity,
-                 mjcPhysicsFlagEquality,
+                 mjcFlagInvdiscrete,
-                 mjcPhysicsFlagEulerdamp,
+                 mjcFlagIsland,
-                 mjcPhysicsFlagFilterparent,
+                 mjcFlagLimit,
-                 mjcPhysicsFlagFrictionloss,
+                 mjcFlagMidphase,
-                 mjcPhysicsFlagFwdinv,
+                 mjcFlagMulticcd,
-                 mjcPhysicsFlagGravity,
+                 mjcFlagNativeccd,
-                 mjcPhysicsFlagInvdiscrete,
+                 mjcFlagOverride,
-                 mjcPhysicsFlagIsland,
+                 mjcFlagPassive,
-                 mjcPhysicsFlagLimit,
+                 mjcFlagRefsafe,
-                 mjcPhysicsFlagMidphase,
+                 mjcFlagSensor,
-                 mjcPhysicsFlagMulticcd,
+                 mjcFlagWarmstart,
-                 mjcPhysicsFlagNativeccd,
+                 mjcOptionActuatorgroupdisable,
-                 mjcPhysicsFlagOverride,
+                 mjcOptionApirate,
-                 mjcPhysicsFlagPassive,
+                 mjcOptionCcd_iterations,
-                 mjcPhysicsFlagRefsafe,
+                 mjcOptionCcd_tolerance,
-                 mjcPhysicsFlagSensor,
+                 mjcOptionCone,
-                 mjcPhysicsFlagWarmstart,
+                 mjcOptionDensity,
-                 mjcPhysicsImpratio,
+                 mjcOptionImpratio,
-                 mjcPhysicsIntegrator,
+                 mjcOptionIntegrator,
-                 mjcPhysicsIterations,
+                 mjcOptionIterations,
-                 mjcPhysicsJacobian,
+                 mjcOptionJacobian,
-                 mjcPhysicsLs_iterations,
+                 mjcOptionLs_iterations,
-                 mjcPhysicsLs_tolerance,
+                 mjcOptionLs_tolerance,
-                 mjcPhysicsMagnetic,
+                 mjcOptionMagnetic,
-                 mjcPhysicsNoslip_iterations,
+                 mjcOptionNoslip_iterations,
-                 mjcPhysicsNoslip_tolerance,
+                 mjcOptionNoslip_tolerance,
-                 mjcPhysicsO_friction,
+                 mjcOptionO_friction,
-                 mjcPhysicsO_margin,
+                 mjcOptionO_margin,
-                 mjcPhysicsO_solimp,
+                 mjcOptionO_solimp,
-                 mjcPhysicsO_solref,
+                 mjcOptionO_solref,
-                 mjcPhysicsSdf_initpoints,
+                 mjcOptionSdf_initpoints,
-                 mjcPhysicsSdf_iterations,
+                 mjcOptionSdf_iterations,
-                 mjcPhysicsSolver,
+                 mjcOptionSolver,
-                 mjcPhysicsTimestep,
+                 mjcOptionTimestep,
-                 mjcPhysicsTolerance,
+                 mjcOptionTolerance,
-                 mjcPhysicsViscosity,
+                 mjcOptionViscosity,
-                 mjcPhysicsWind,
+                 mjcOptionWind,
                  newton,
                  pgs,
                  pyramidal,

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;
+  const TfToken mjcFlagActuation;
-  /// \brief "mjc:physics:apirate"
+  /// \brief "mjc:flag:autoreset"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsApirate;
+  const TfToken mjcFlagAutoreset;
-  /// \brief "mjc:physics:ccd_iterations"
+  /// \brief "mjc:flag:clampctrl"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsCcd_iterations;
+  const TfToken mjcFlagClampctrl;
-  /// \brief "mjc:physics:ccd_tolerance"
+  /// \brief "mjc:flag:constraint"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsCcd_tolerance;
+  const TfToken mjcFlagConstraint;
-  /// \brief "mjc:physics:cone"
+  /// \brief "mjc:flag:contact"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsCone;
+  const TfToken mjcFlagContact;
-  /// \brief "mjc:physics:density"
+  /// \brief "mjc:flag:energy"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsDensity;
+  const TfToken mjcFlagEnergy;
-  /// \brief "mjc:physics:flag:actuation"
+  /// \brief "mjc:flag:equality"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagActuation;
+  const TfToken mjcFlagEquality;
-  /// \brief "mjc:physics:flag:autoreset"
+  /// \brief "mjc:flag:eulerdamp"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagAutoreset;
+  const TfToken mjcFlagEulerdamp;
-  /// \brief "mjc:physics:flag:clampctrl"
+  /// \brief "mjc:flag:filterparent"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagClampctrl;
+  const TfToken mjcFlagFilterparent;
-  /// \brief "mjc:physics:flag:constraint"
+  /// \brief "mjc:flag:frictionloss"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagConstraint;
+  const TfToken mjcFlagFrictionloss;
-  /// \brief "mjc:physics:flag:contact"
+  /// \brief "mjc:flag:fwdinv"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagContact;
+  const TfToken mjcFlagFwdinv;
-  /// \brief "mjc:physics:flag:energy"
+  /// \brief "mjc:flag:gravity"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagEnergy;
+  const TfToken mjcFlagGravity;
-  /// \brief "mjc:physics:flag:equality"
+  /// \brief "mjc:flag:invdiscrete"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagEquality;
+  const TfToken mjcFlagInvdiscrete;
-  /// \brief "mjc:physics:flag:eulerdamp"
+  /// \brief "mjc:flag:island"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagEulerdamp;
+  const TfToken mjcFlagIsland;
-  /// \brief "mjc:physics:flag:filterparent"
+  /// \brief "mjc:flag:limit"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagFilterparent;
+  const TfToken mjcFlagLimit;
-  /// \brief "mjc:physics:flag:frictionloss"
+  /// \brief "mjc:flag:midphase"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagFrictionloss;
+  const TfToken mjcFlagMidphase;
-  /// \brief "mjc:physics:flag:fwdinv"
+  /// \brief "mjc:flag:multiccd"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagFwdinv;
+  const TfToken mjcFlagMulticcd;
-  /// \brief "mjc:physics:flag:gravity"
+  /// \brief "mjc:flag:nativeccd"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagGravity;
+  const TfToken mjcFlagNativeccd;
-  /// \brief "mjc:physics:flag:invdiscrete"
+  /// \brief "mjc:flag:override"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagInvdiscrete;
+  const TfToken mjcFlagOverride;
-  /// \brief "mjc:physics:flag:island"
+  /// \brief "mjc:flag:passive"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagIsland;
+  const TfToken mjcFlagPassive;
-  /// \brief "mjc:physics:flag:limit"
+  /// \brief "mjc:flag:refsafe"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagLimit;
+  const TfToken mjcFlagRefsafe;
-  /// \brief "mjc:physics:flag:midphase"
+  /// \brief "mjc:flag:sensor"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagMidphase;
+  const TfToken mjcFlagSensor;
-  /// \brief "mjc:physics:flag:multiccd"
+  /// \brief "mjc:flag:warmstart"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagMulticcd;
+  const TfToken mjcFlagWarmstart;
-  /// \brief "mjc:physics:flag:nativeccd"
+  /// \brief "mjc:option:actuatorgroupdisable"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagNativeccd;
+  const TfToken mjcOptionActuatorgroupdisable;
-  /// \brief "mjc:physics:flag:override"
+  /// \brief "mjc:option:apirate"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagOverride;
+  const TfToken mjcOptionApirate;
-  /// \brief "mjc:physics:flag:passive"
+  /// \brief "mjc:option:ccd_iterations"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagPassive;
+  const TfToken mjcOptionCcd_iterations;
-  /// \brief "mjc:physics:flag:refsafe"
+  /// \brief "mjc:option:ccd_tolerance"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagRefsafe;
+  const TfToken mjcOptionCcd_tolerance;
-  /// \brief "mjc:physics:flag:sensor"
+  /// \brief "mjc:option:cone"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagSensor;
+  const TfToken mjcOptionCone;
-  /// \brief "mjc:physics:flag:warmstart"
+  /// \brief "mjc:option:density"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsFlagWarmstart;
+  const TfToken mjcOptionDensity;
-  /// \brief "mjc:physics:impratio"
+  /// \brief "mjc:option:impratio"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsImpratio;
+  const TfToken mjcOptionImpratio;
-  /// \brief "mjc:physics:integrator"
+  /// \brief "mjc:option:integrator"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsIntegrator;
+  const TfToken mjcOptionIntegrator;
-  /// \brief "mjc:physics:iterations"
+  /// \brief "mjc:option:iterations"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsIterations;
+  const TfToken mjcOptionIterations;
-  /// \brief "mjc:physics:jacobian"
+  /// \brief "mjc:option:jacobian"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsJacobian;
+  const TfToken mjcOptionJacobian;
-  /// \brief "mjc:physics:ls_iterations"
+  /// \brief "mjc:option:ls_iterations"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsLs_iterations;
+  const TfToken mjcOptionLs_iterations;
-  /// \brief "mjc:physics:ls_tolerance"
+  /// \brief "mjc:option:ls_tolerance"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsLs_tolerance;
+  const TfToken mjcOptionLs_tolerance;
-  /// \brief "mjc:physics:magnetic"
+  /// \brief "mjc:option:magnetic"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsMagnetic;
+  const TfToken mjcOptionMagnetic;
-  /// \brief "mjc:physics:noslip_iterations"
+  /// \brief "mjc:option:noslip_iterations"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsNoslip_iterations;
+  const TfToken mjcOptionNoslip_iterations;
-  /// \brief "mjc:physics:noslip_tolerance"
+  /// \brief "mjc:option:noslip_tolerance"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsNoslip_tolerance;
+  const TfToken mjcOptionNoslip_tolerance;
-  /// \brief "mjc:physics:o_friction"
+  /// \brief "mjc:option:o_friction"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsO_friction;
+  const TfToken mjcOptionO_friction;
-  /// \brief "mjc:physics:o_margin"
+  /// \brief "mjc:option:o_margin"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsO_margin;
+  const TfToken mjcOptionO_margin;
-  /// \brief "mjc:physics:o_solimp"
+  /// \brief "mjc:option:o_solimp"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsO_solimp;
+  const TfToken mjcOptionO_solimp;
-  /// \brief "mjc:physics:o_solref"
+  /// \brief "mjc:option:o_solref"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsO_solref;
+  const TfToken mjcOptionO_solref;
-  /// \brief "mjc:physics:sdf_initpoints"
+  /// \brief "mjc:option:sdf_initpoints"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsSdf_initpoints;
+  const TfToken mjcOptionSdf_initpoints;
-  /// \brief "mjc:physics:sdf_iterations"
+  /// \brief "mjc:option:sdf_iterations"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsSdf_iterations;
+  const TfToken mjcOptionSdf_iterations;
-  /// \brief "mjc:physics:solver"
+  /// \brief "mjc:option:solver"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsSolver;
+  const TfToken mjcOptionSolver;
-  /// \brief "mjc:physics:timestep"
+  /// \brief "mjc:option:timestep"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsTimestep;
+  const TfToken mjcOptionTimestep;
-  /// \brief "mjc:physics:tolerance"
+  /// \brief "mjc:option:tolerance"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsTolerance;
+  const TfToken mjcOptionTolerance;
-  /// \brief "mjc:physics:viscosity"
+  /// \brief "mjc:option:viscosity"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsViscosity;
+  const TfToken mjcOptionViscosity;
-  /// \brief "mjc:physics:wind"
+  /// \brief "mjc:option:wind"
   ///
   /// MjcPhysicsSceneAPI
-  const TfToken mjcPhysicsWind;
+  const TfToken mjcOptionWind;
   /// \brief "newton"
   ///
   /// Fallback value for MjcPhysicsSceneAPI::GetSolverAttr(),  This token