Add mujoco compiler settings to MjcSceneAPI in mjcPhysics.

PiperOrigin-RevId: 783729333
Change-Id: Ic1c3e4fb47a901de4eebdc2e987d276f4202d9ed

Author: havess

include/mujoco/experimental/usd/mjcPhysics/sceneAPI.h

@@ -60,8 +60,9 @@ struct MjcPhysicsTokensType {
   const TfToken affine;
   /// \brief "auto"
   ///
-  /// Fallback value for MjcPhysicsSceneAPI::GetJacobianAttr(), Fallback value
-  /// for MjcPhysicsActuator::GetMjcActLimitedAttr(), Fallback value for
+  /// Fallback value for MjcPhysicsSceneAPI::GetInertiaFromGeomAttr(), Fallback
+  /// value for MjcPhysicsSceneAPI::GetJacobianAttr(), Fallback value for
+  /// MjcPhysicsActuator::GetMjcActLimitedAttr(), Fallback value for
   /// MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Fallback value for
   /// MjcPhysicsActuator::GetMjcForceLimitedAttr(), Fallback value for
   /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr(),  This token represents
@@ -76,6 +77,10 @@ struct MjcPhysicsTokensType {
   ///
   /// Possible value for MjcPhysicsMeshCollisionAPI::GetInertiaAttr()
   const TfToken convex;
+  /// \brief "degree"
+  ///
+  /// Fallback value for MjcPhysicsSceneAPI::GetAngleAttr()
+  const TfToken degree;
   /// \brief "dense"
   ///
   /// Possible value for MjcPhysicsSceneAPI::GetJacobianAttr(),  This token
@@ -97,8 +102,9 @@ struct MjcPhysicsTokensType {
   const TfToken exact;
   /// \brief "false"
   ///
-  /// Possible value for MjcPhysicsActuator::GetMjcActLimitedAttr(), Possible
-  /// value for MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Possible value for
+  /// Possible value for MjcPhysicsSceneAPI::GetInertiaFromGeomAttr(), Possible
+  /// value for MjcPhysicsActuator::GetMjcActLimitedAttr(), Possible value for
+  /// MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Possible value for
   /// MjcPhysicsActuator::GetMjcForceLimitedAttr(), Possible value for
   /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr()
   const TfToken false_;
@@ -184,6 +190,62 @@ struct MjcPhysicsTokensType {
   ///
   /// MjcPhysicsActuator
   const TfToken mjcBiasType;
+  /// \brief "mjc:compiler:alignFree"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerAlignFree;
+  /// \brief "mjc:compiler:angle"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerAngle;
+  /// \brief "mjc:compiler:autoLimits"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerAutoLimits;
+  /// \brief "mjc:compiler:balanceInertia"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerBalanceInertia;
+  /// \brief "mjc:compiler:boundInertia"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerBoundInertia;
+  /// \brief "mjc:compiler:boundMass"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerBoundMass;
+  /// \brief "mjc:compiler:fitAABB"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerFitAABB;
+  /// \brief "mjc:compiler:fuseStatic"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerFuseStatic;
+  /// \brief "mjc:compiler:inertiaFromGeom"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerInertiaFromGeom;
+  /// \brief "mjc:compiler:inertiaGroupRange:max"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerInertiaGroupRangeMax;
+  /// \brief "mjc:compiler:inertiaGroupRange:min"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerInertiaGroupRangeMin;
+  /// \brief "mjc:compiler:saveInertial"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerSaveInertial;
+  /// \brief "mjc:compiler:setTotalMass"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerSetTotalMass;
+  /// \brief "mjc:compiler:useThread"
+  ///
+  /// MjcPhysicsSceneAPI
+  const TfToken mjcCompilerUseThread;
   /// \brief "mjc:condim"
   ///
   /// MjcPhysicsCollisionAPI
@@ -595,6 +657,10 @@ struct MjcPhysicsTokensType {
   /// Fallback value for MjcPhysicsSceneAPI::GetConeAttr(),  This token
   /// represents the pyramidal contact friction cone type.
   const TfToken pyramidal;
+  /// \brief "radian"
+  ///
+  /// Possible value for MjcPhysicsSceneAPI::GetAngleAttr()
+  const TfToken radian;
   /// \brief "rk4"
   ///
   /// Possible value for MjcPhysicsSceneAPI::GetIntegratorAttr(),  This token
@@ -611,8 +677,9 @@ struct MjcPhysicsTokensType {
   const TfToken sparse;
   /// \brief "true"
   ///
-  /// Possible value for MjcPhysicsActuator::GetMjcActLimitedAttr(), Possible
-  /// value for MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Possible value for
+  /// Possible value for MjcPhysicsSceneAPI::GetInertiaFromGeomAttr(), Possible
+  /// value for MjcPhysicsActuator::GetMjcActLimitedAttr(), Possible value for
+  /// MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Possible value for
   /// MjcPhysicsActuator::GetMjcForceLimitedAttr(), Possible value for
   /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr()
   const TfToken true_;

include/mujoco/experimental/usd/mjcPhysics/tokens.h

@@ -7,6 +7,69 @@ class "MjcSceneAPI" (
     doc = "API providing global simulation options for MuJoCo."
 )
 {
+    uniform bool mjc:compiler:alignFree = 0 (
+        displayName = "Align Free"
+        doc = "This attribute toggles the default behaviour of an optimization that applies to bodies with a free joint and no child bodies. When True, the body frame and free joint will automatically be aligned with inertial frame, which leads to both faster and more stable simulation."
+    )
+    uniform token mjc:compiler:angle = "degree" (
+        allowedTokens = ["degree", "radian"]
+        displayName = "Angle"
+        doc = "This attribute specifies whether the angles in mjcPhysics attributes have units of degrees or radians if not otherwise noted."
+    )
+    uniform bool mjc:compiler:autoLimits = 1 (
+        displayName = "Automatic Limits"
+        doc = 'This attribute affects the behavior of attributes such as "limited" (on MjcJointAPI), "forcelimited" "ctrllimited", and "actlimited" (on MjcActuator). If True, these attributes are unnecessary and their value will be inferred from the presence of their corresponding "range" attribute. If False, no such inference will happen: For a joint to be limited, both limited=True and range:min/max must be specified. In this mode, it is an error to specify a range without a limit.'
+    )
+    uniform bool mjc:compiler:balanceInertia = 0 (
+        displayName = "Balance Inertia"
+        doc = 'A valid diagonal inertia matrix must satisfy A+B>=C for all permutations of the three diagonal elements. Some poorly designed models violate this constraint, which will normally result in a compile error. If this attribute is set to "true", the compiler will silently set all three diagonal elements to their average value whenever the above condition is violated.'
+    )
+    uniform double mjc:compiler:boundInertia = 0 (
+        displayName = "Bound Inertia"
+        doc = "This attribute imposes a lower bound on the diagonal inertia components of each body except for the world body."
+    )
+    uniform double mjc:compiler:boundMass = 0 (
+        displayName = "Bound Mass"
+        doc = "This attribute imposes a lower bound on the mass of each body except for the world body."
+    )
+    uniform bool mjc:compiler:fitAABB = 0 (
+        displayName = "Fit AABB"
+        doc = "The compiler is able to replace a mesh with a geometric primitive fitted to that mesh. If this attribute is True, the fitting procedure uses the axis-aligned bounding box (AABB) of the mesh. Otherwise it uses the equivalent-inertia box of the mesh."
+    )
+    uniform bool mjc:compiler:fuseStatic = 0 (
+        displayName = "Fuse Static"
+        doc = """This attribute controls a compiler optimization feature where static bodies are fused with their parent, and any elements defined in those bodies are reassigned to the parent. Static bodies are fused with their parent unless
+
+* They are referenced by another element in the model.
+
+* They contain a site which is referenced by a force or torque sensor.
+"""
+    )
+    uniform token mjc:compiler:inertiaFromGeom = "auto" (
+        allowedTokens = ["false", "true", "auto"]
+        displayName = "Inertia From Geom"
+        doc = 'This attribute controls the automatic inference of body masses and inertias from geoms attached to the body. If this setting is "false", no automatic inference is performed. In that case each body must have explicitly defined mass and inertia with the inertial element, or else a compile error will be generated. If this setting is "true", the mass and inertia of each body will be inferred from the geoms attached to it, overriding any values specified with the inertial element. The default setting "auto" means that masses and inertias are inferred automatically only when the inertial element is missing in the body definition. One reason to set this attribute to "true" instead of "auto" is to override inertial data imported from a poorly designed model.'
+    )
+    uniform int mjc:compiler:inertiaGroupRange:max = 5 (
+        displayName = "Inertia Group Range Max"
+        doc = "This attribute specifies the maximum of the geom group range that is used to infer body masses and inertias (when such inference is enabled). The group attribute of geom is an integer. If this integer falls in the range specified here, the geom will be used in the inertial computation, otherwise it will be ignored. This feature is useful in models that have redundant sets of geoms for collision and visualization. Note that the world body does not participate in the inertial computations, so any geoms attached to it are automatically ignored. Therefore it is not necessary to adjust this attribute and the geom-specific groups so as to exclude world geoms from the inertial computation."
+    )
+    uniform int mjc:compiler:inertiaGroupRange:min = 0 (
+        displayName = "Inertia Group Range Min"
+        doc = "This attribute specifies the maximum of the geom group range that is used to infer body masses and inertias (when such inference is enabled). The group attribute of geom is an integer. If this integer falls in the range specified here, the collider will be used in the inertial computation, otherwise it will be ignored. Note that the world body does not participate in the inertial computations, so any geoms attached to it are automatically ignored. Therefore it is not necessary to adjust this attribute and the geom-specific groups so as to exclude world geoms from the inertial computation."
+    )
+    uniform bool mjc:compiler:saveInertial = 0 (
+        displayName = "Save Inertial"
+        doc = "If True, the compiler will save explicit inertial clauses for all bodies."
+    )
+    uniform double mjc:compiler:setTotalMass = -1 (
+        displayName = "Set Total Mass"
+        doc = "If this value is positive, the compiler will scale the masses and inertias of all bodies in the model, so that the total mass equals the value specified here. The world body has mass 0 and does not participate in any mass-related computations. This scaling is performed last, after all other operations affecting the body mass and inertia. The same scaling operation can be applied at runtime to the compiled mjModel with the function mj_setTotalmass."
+    )
+    uniform bool mjc:compiler:useThread = 1 (
+        displayName = "Use Thread"
+        doc = "If this is True, the model compiler will run in multi-threaded mode. Currently multi-threading is used for computing the length ranges of actuators and for parallel loading of meshes."
+    )
     uniform bool mjc:flag:actuation = 1 (
         displayName = "Actuation Forces Toggle"
         doc = "Enables all standard computations related to actuator forces, including actuator dynamics."

src/experimental/usd/mjcPhysics/generatedSchema.usda

@@ -615,6 +615,162 @@ UsdAttribute MjcPhysicsSceneAPI::CreateIslandFlagAttr(
       /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
 }
 
+UsdAttribute MjcPhysicsSceneAPI::GetAutoLimitsAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerAutoLimits);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateAutoLimitsAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerAutoLimits, SdfValueTypeNames->Bool,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetBoundMassAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerBoundMass);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateBoundMassAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerBoundMass, SdfValueTypeNames->Double,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetBoundInertiaAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerBoundInertia);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateBoundInertiaAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerBoundInertia, SdfValueTypeNames->Double,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetSetTotalMassAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerSetTotalMass);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateSetTotalMassAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerSetTotalMass, SdfValueTypeNames->Double,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetUseThreadAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerUseThread);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateUseThreadAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerUseThread, SdfValueTypeNames->Bool,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetBalanceInertiaAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerBalanceInertia);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateBalanceInertiaAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerBalanceInertia, SdfValueTypeNames->Bool,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetAngleAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerAngle);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateAngleAttr(VtValue const &defaultValue,
+                                                 bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerAngle, SdfValueTypeNames->Token,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetFitAABBAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerFitAABB);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateFitAABBAttr(VtValue const &defaultValue,
+                                                   bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerFitAABB, SdfValueTypeNames->Bool,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetFuseStaticAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerFuseStatic);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateFuseStaticAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerFuseStatic, SdfValueTypeNames->Bool,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetInertiaFromGeomAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerInertiaFromGeom);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateInertiaFromGeomAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerInertiaFromGeom, SdfValueTypeNames->Token,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetAlignFreeAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerAlignFree);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateAlignFreeAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerAlignFree, SdfValueTypeNames->Bool,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetInertiaGroupRangeMinAttr() const {
+  return GetPrim().GetAttribute(
+      MjcPhysicsTokens->mjcCompilerInertiaGroupRangeMin);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateInertiaGroupRangeMinAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerInertiaGroupRangeMin, SdfValueTypeNames->Int,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetInertiaGroupRangeMaxAttr() const {
+  return GetPrim().GetAttribute(
+      MjcPhysicsTokens->mjcCompilerInertiaGroupRangeMax);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateInertiaGroupRangeMaxAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerInertiaGroupRangeMax, SdfValueTypeNames->Int,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::GetSaveInertialAttr() const {
+  return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCompilerSaveInertial);
+}
+
+UsdAttribute MjcPhysicsSceneAPI::CreateSaveInertialAttr(
+    VtValue const &defaultValue, bool writeSparsely) const {
+  return UsdSchemaBase::_CreateAttr(
+      MjcPhysicsTokens->mjcCompilerSaveInertial, SdfValueTypeNames->Bool,
+      /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely);
+}
+
 namespace {
 static inline TfTokenVector _ConcatenateAttributeNames(
     const TfTokenVector &left, const TfTokenVector &right) {
@@ -679,6 +835,20 @@ const TfTokenVector &MjcPhysicsSceneAPI::GetSchemaAttributeNames(
       MjcPhysicsTokens->mjcFlagInvdiscrete,
       MjcPhysicsTokens->mjcFlagMulticcd,
       MjcPhysicsTokens->mjcFlagIsland,
+      MjcPhysicsTokens->mjcCompilerAutoLimits,
+      MjcPhysicsTokens->mjcCompilerBoundMass,
+      MjcPhysicsTokens->mjcCompilerBoundInertia,
+      MjcPhysicsTokens->mjcCompilerSetTotalMass,
+      MjcPhysicsTokens->mjcCompilerUseThread,
+      MjcPhysicsTokens->mjcCompilerBalanceInertia,
+      MjcPhysicsTokens->mjcCompilerAngle,
+      MjcPhysicsTokens->mjcCompilerFitAABB,
+      MjcPhysicsTokens->mjcCompilerFuseStatic,
+      MjcPhysicsTokens->mjcCompilerInertiaFromGeom,
+      MjcPhysicsTokens->mjcCompilerAlignFree,
+      MjcPhysicsTokens->mjcCompilerInertiaGroupRangeMin,
+      MjcPhysicsTokens->mjcCompilerInertiaGroupRangeMax,
+      MjcPhysicsTokens->mjcCompilerSaveInertial,
   };
   static TfTokenVector allNames = _ConcatenateAttributeNames(
       UsdAPISchemaBase::GetSchemaAttributeNames(true), localNames);