diff --git a/include/mujoco/experimental/usd/mjcPhysics/tokens.h b/include/mujoco/experimental/usd/mjcPhysics/tokens.h index 46ff1ad3..202a1e3c 100644 --- a/include/mujoco/experimental/usd/mjcPhysics/tokens.h +++ b/include/mujoco/experimental/usd/mjcPhysics/tokens.h @@ -55,15 +55,15 @@ struct MjcPhysicsTokensType { MJCPHYSICS_API MjcPhysicsTokensType(); /// \brief "affine" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcBiasTypeAttr(), Possible - /// value for MjcPhysicsActuatorAPI::GetMjcGainTypeAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Possible + /// value for MjcPhysicsTransmission::GetMjcGainTypeAttr() const TfToken affine; /// \brief "auto" /// /// Fallback value for MjcPhysicsSceneAPI::GetJacobianAttr(), Fallback value - /// for MjcPhysicsActuatorAPI::GetMjcActLimitedAttr(), Fallback value for - /// MjcPhysicsActuatorAPI::GetMjcCtrlLimitedAttr(), Fallback value for - /// MjcPhysicsActuatorAPI::GetMjcForceLimitedAttr(), Fallback value for + /// for MjcPhysicsTransmission::GetMjcActLimitedAttr(), Fallback value for + /// MjcPhysicsTransmission::GetMjcCtrlLimitedAttr(), Fallback value for + /// MjcPhysicsTransmission::GetMjcForceLimitedAttr(), Fallback value for /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr(), This token represents /// the auto constraint Jacobian and matrices computed from it. const TfToken auto_; @@ -97,22 +97,22 @@ struct MjcPhysicsTokensType { const TfToken exact; /// \brief "false" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcActLimitedAttr(), Possible - /// value for MjcPhysicsActuatorAPI::GetMjcCtrlLimitedAttr(), Possible value - /// for MjcPhysicsActuatorAPI::GetMjcForceLimitedAttr(), Possible value for - /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcActLimitedAttr(), + /// Possible value for MjcPhysicsTransmission::GetMjcCtrlLimitedAttr(), + /// Possible value for MjcPhysicsTransmission::GetMjcForceLimitedAttr(), + /// Possible value for MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() const TfToken false_; /// \brief "filter" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcDynTypeAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcDynTypeAttr() const TfToken filter; /// \brief "filterexact" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcDynTypeAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcDynTypeAttr() const TfToken filterexact; /// \brief "fixed" /// - /// Fallback value for MjcPhysicsActuatorAPI::GetMjcGainTypeAttr() + /// Fallback value for MjcPhysicsTransmission::GetMjcGainTypeAttr() const TfToken fixed; /// \brief "implicit" /// @@ -126,7 +126,7 @@ struct MjcPhysicsTokensType { const TfToken implicitfast; /// \brief "integrator" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcDynTypeAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcDynTypeAttr() const TfToken integrator; /// \brief "legacy" /// @@ -138,23 +138,23 @@ struct MjcPhysicsTokensType { const TfToken mjcAct; /// \brief "mjc:actDim" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcActDim; /// \brief "mjc:actEarly" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcActEarly; /// \brief "mjc:actLimited" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcActLimited; /// \brief "mjc:actRange:max" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcActRangeMax; /// \brief "mjc:actRange:min" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcActRangeMin; /// \brief "mjc:actuatorfrclimited" /// @@ -178,15 +178,15 @@ struct MjcPhysicsTokensType { const TfToken mjcArmature; /// \brief "mjc:biasPrm" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcBiasPrm; /// \brief "mjc:biasType" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcBiasType; /// \brief "mjc:crankLength" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcCrankLength; /// \brief "mjc:ctrl" /// @@ -194,15 +194,15 @@ struct MjcPhysicsTokensType { const TfToken mjcCtrl; /// \brief "mjc:ctrlLimited" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcCtrlLimited; /// \brief "mjc:ctrlRange:max" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcCtrlRangeMax; /// \brief "mjc:ctrlRange:min" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcCtrlRangeMin; /// \brief "mjc:damping" /// @@ -210,11 +210,11 @@ struct MjcPhysicsTokensType { const TfToken mjcDamping; /// \brief "mjc:dynPrm" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcDynPrm; /// \brief "mjc:dynType" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcDynType; /// \brief "mjc:flag:actuation" /// @@ -310,15 +310,15 @@ struct MjcPhysicsTokensType { const TfToken mjcFlagWarmstart; /// \brief "mjc:forceLimited" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcForceLimited; /// \brief "mjc:forceRange:max" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcForceRangeMax; /// \brief "mjc:forceRange:min" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcForceRangeMin; /// \brief "mjc:frictionloss" /// @@ -326,31 +326,35 @@ struct MjcPhysicsTokensType { const TfToken mjcFrictionloss; /// \brief "mjc:gainPrm" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcGainPrm; /// \brief "mjc:gainType" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcGainType; /// \brief "mjc:gear" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcGear; + /// \brief "mjc:group" + /// + /// MjcPhysicsTransmission + const TfToken mjcGroup; /// \brief "mjc:inertia" /// /// MjcPhysicsMeshCollisionAPI const TfToken mjcInertia; /// \brief "mjc:jointInParent" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcJointInParent; /// \brief "mjc:lengthRange:max" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcLengthRangeMax; /// \brief "mjc:lengthRange:min" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcLengthRangeMin; /// \brief "mjc:margin" /// @@ -486,7 +490,7 @@ struct MjcPhysicsTokensType { const TfToken mjcRef; /// \brief "mjc:refSite" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcRefSite; /// \brief "mjc:shellinertia" /// @@ -494,7 +498,7 @@ struct MjcPhysicsTokensType { const TfToken mjcShellinertia; /// \brief "mjc:sliderSite" /// - /// MjcPhysicsActuatorAPI + /// MjcPhysicsTransmission const TfToken mjcSliderSite; /// \brief "mjc:solimpfriction" /// @@ -524,11 +528,15 @@ struct MjcPhysicsTokensType { /// /// MjcPhysicsJointAPI const TfToken mjcStiffness; + /// \brief "mjc:target" + /// + /// MjcPhysicsTransmission + const TfToken mjcTarget; /// \brief "muscle" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcBiasTypeAttr(), Possible - /// value for MjcPhysicsActuatorAPI::GetMjcDynTypeAttr(), Possible value for - /// MjcPhysicsActuatorAPI::GetMjcGainTypeAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Possible + /// value for MjcPhysicsTransmission::GetMjcDynTypeAttr(), Possible value for + /// MjcPhysicsTransmission::GetMjcGainTypeAttr() const TfToken muscle; /// \brief "newton" /// @@ -537,8 +545,8 @@ struct MjcPhysicsTokensType { const TfToken newton; /// \brief "none" /// - /// Fallback value for MjcPhysicsActuatorAPI::GetMjcBiasTypeAttr(), Fallback - /// value for MjcPhysicsActuatorAPI::GetMjcDynTypeAttr() + /// Fallback value for MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Fallback + /// value for MjcPhysicsTransmission::GetMjcDynTypeAttr() const TfToken none; /// \brief "pgs" /// @@ -566,21 +574,17 @@ struct MjcPhysicsTokensType { const TfToken sparse; /// \brief "true" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcActLimitedAttr(), Possible - /// value for MjcPhysicsActuatorAPI::GetMjcCtrlLimitedAttr(), Possible value - /// for MjcPhysicsActuatorAPI::GetMjcForceLimitedAttr(), Possible value for - /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcActLimitedAttr(), + /// Possible value for MjcPhysicsTransmission::GetMjcCtrlLimitedAttr(), + /// Possible value for MjcPhysicsTransmission::GetMjcForceLimitedAttr(), + /// Possible value for MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() const TfToken true_; /// \brief "user" /// - /// Possible value for MjcPhysicsActuatorAPI::GetMjcBiasTypeAttr(), Possible - /// value for MjcPhysicsActuatorAPI::GetMjcDynTypeAttr(), Possible value for - /// MjcPhysicsActuatorAPI::GetMjcGainTypeAttr() + /// Possible value for MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Possible + /// value for MjcPhysicsTransmission::GetMjcDynTypeAttr(), Possible value for + /// MjcPhysicsTransmission::GetMjcGainTypeAttr() const TfToken user; - /// \brief "MjcActuatorAPI" - /// - /// Schema identifier and family for MjcPhysicsActuatorAPI - const TfToken MjcActuatorAPI; /// \brief "MjcCollisionAPI" /// /// Schema identifier and family for MjcPhysicsCollisionAPI @@ -605,6 +609,10 @@ struct MjcPhysicsTokensType { /// /// Schema identifier and family for MjcPhysicsSiteAPI const TfToken MjcSiteAPI; + /// \brief "MjcTransmission" + /// + /// Schema identifier and family for MjcPhysicsTransmission + const TfToken MjcTransmission; /// A vector of all of the tokens listed above. const std::vector allTokens; }; diff --git a/include/mujoco/experimental/usd/mjcPhysics/actuatorAPI.h b/include/mujoco/experimental/usd/mjcPhysics/transmission.h similarity index 89% rename from include/mujoco/experimental/usd/mjcPhysics/actuatorAPI.h rename to include/mujoco/experimental/usd/mjcPhysics/transmission.h index 3cd5a132..816b1b1b 100644 --- a/include/mujoco/experimental/usd/mjcPhysics/actuatorAPI.h +++ b/include/mujoco/experimental/usd/mjcPhysics/transmission.h @@ -12,10 +12,10 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef MJCPHYSICS_GENERATED_ACTUATORAPI_H -#define MJCPHYSICS_GENERATED_ACTUATORAPI_H +#ifndef MJCPHYSICS_GENERATED_TRANSMISSION_H +#define MJCPHYSICS_GENERATED_TRANSMISSION_H -/// \file mjcPhysics/actuatorAPI.h +/// \file mjcPhysics/transmission.h #include #include @@ -26,50 +26,51 @@ #include #include #include -#include #include #include +#include PXR_NAMESPACE_OPEN_SCOPE class SdfAssetPath; // -------------------------------------------------------------------------- // -// MJCACTUATORAPI // +// MJCTRANSMISSION // // -------------------------------------------------------------------------- // -/// \class MjcPhysicsActuatorAPI +/// \class MjcPhysicsTransmission /// -/// API describing a Mujoco actuator. +/// Known as actuator in MuJoCo, this prim represents force transmission to +/// joints, bodies, or sites. /// /// For any described attribute \em Fallback \em Value or \em Allowed \em Values /// below that are text/tokens, the actual token is published and defined in /// \ref MjcPhysicsTokens. So to set an attribute to the value "rightHanded", /// use MjcPhysicsTokens->rightHanded as the value. /// -class MjcPhysicsActuatorAPI : public UsdAPISchemaBase { +class MjcPhysicsTransmission : public UsdTyped { public: /// Compile time constant representing what kind of schema this class is. /// /// \sa UsdSchemaKind - static const UsdSchemaKind schemaKind = UsdSchemaKind::SingleApplyAPI; + static const UsdSchemaKind schemaKind = UsdSchemaKind::ConcreteTyped; - /// Construct a MjcPhysicsActuatorAPI on UsdPrim \p prim . - /// Equivalent to MjcPhysicsActuatorAPI::Get(prim.GetStage(), prim.GetPath()) + /// Construct a MjcPhysicsTransmission on UsdPrim \p prim . + /// Equivalent to MjcPhysicsTransmission::Get(prim.GetStage(), prim.GetPath()) /// for a \em valid \p prim, but will not immediately throw an error for /// an invalid \p prim - explicit MjcPhysicsActuatorAPI(const UsdPrim &prim = UsdPrim()) - : UsdAPISchemaBase(prim) {} + explicit MjcPhysicsTransmission(const UsdPrim &prim = UsdPrim()) + : UsdTyped(prim) {} - /// Construct a MjcPhysicsActuatorAPI on the prim held by \p schemaObj . - /// Should be preferred over MjcPhysicsActuatorAPI(schemaObj.GetPrim()), + /// Construct a MjcPhysicsTransmission on the prim held by \p schemaObj . + /// Should be preferred over MjcPhysicsTransmission(schemaObj.GetPrim()), /// as it preserves SchemaBase state. - explicit MjcPhysicsActuatorAPI(const UsdSchemaBase &schemaObj) - : UsdAPISchemaBase(schemaObj) {} + explicit MjcPhysicsTransmission(const UsdSchemaBase &schemaObj) + : UsdTyped(schemaObj) {} /// Destructor. MJCPHYSICS_API - virtual ~MjcPhysicsActuatorAPI(); + virtual ~MjcPhysicsTransmission(); /// Return a vector of names of all pre-declared attributes for this schema /// class and all its ancestor classes. Does not include attributes that @@ -78,55 +79,44 @@ class MjcPhysicsActuatorAPI : public UsdAPISchemaBase { static const TfTokenVector &GetSchemaAttributeNames( bool includeInherited = true); - /// Return a MjcPhysicsActuatorAPI holding the prim adhering to this + /// Return a MjcPhysicsTransmission holding the prim adhering to this /// schema at \p path on \p stage. If no prim exists at \p path on /// \p stage, or if the prim at that path does not adhere to this schema, /// return an invalid schema object. This is shorthand for the following: /// /// \code - /// MjcPhysicsActuatorAPI(stage->GetPrimAtPath(path)); + /// MjcPhysicsTransmission(stage->GetPrimAtPath(path)); /// \endcode /// MJCPHYSICS_API - static MjcPhysicsActuatorAPI Get(const UsdStagePtr &stage, - const SdfPath &path); + static MjcPhysicsTransmission Get(const UsdStagePtr &stage, + const SdfPath &path); - /// Returns true if this single-apply API schema can be applied to - /// the given \p prim. If this schema can not be a applied to the prim, - /// this returns false and, if provided, populates \p whyNot with the - /// reason it can not be applied. + /// Attempt to ensure a \a UsdPrim adhering to this schema at \p path + /// is defined (according to UsdPrim::IsDefined()) on this stage. /// - /// Note that if CanApply returns false, that does not necessarily imply - /// that calling Apply will fail. Callers are expected to call CanApply - /// before calling Apply if they want to ensure that it is valid to - /// apply a schema. + /// If a prim adhering to this schema at \p path is already defined on this + /// stage, return that prim. Otherwise author an \a SdfPrimSpec with + /// \a specifier == \a SdfSpecifierDef and this schema's prim type name for + /// the prim at \p path at the current EditTarget. Author \a SdfPrimSpec s + /// with \p specifier == \a SdfSpecifierDef and empty typeName at the + /// current EditTarget for any nonexistent, or existing but not \a Defined + /// ancestors. /// - /// \sa UsdPrim::GetAppliedSchemas() - /// \sa UsdPrim::HasAPI() - /// \sa UsdPrim::CanApplyAPI() - /// \sa UsdPrim::ApplyAPI() - /// \sa UsdPrim::RemoveAPI() + /// The given \a path must be an absolute prim path that does not contain + /// any variant selections. + /// + /// If it is impossible to author any of the necessary PrimSpecs, (for + /// example, in case \a path cannot map to the current UsdEditTarget's + /// namespace) issue an error and return an invalid \a UsdPrim. + /// + /// Note that this method may return a defined prim whose typeName does not + /// specify this schema class, in case a stronger typeName opinion overrides + /// the opinion at the current EditTarget. /// MJCPHYSICS_API - static bool CanApply(const UsdPrim &prim, std::string *whyNot = nullptr); - - /// Applies this single-apply API schema to the given \p prim. - /// This information is stored by adding "MjcActuatorAPI" to the - /// token-valued, listOp metadata \em apiSchemas on the prim. - /// - /// \return A valid MjcPhysicsActuatorAPI object is returned upon success. - /// An invalid (or empty) MjcPhysicsActuatorAPI object is returned upon - /// failure. See \ref UsdPrim::ApplyAPI() for conditions - /// resulting in failure. - /// - /// \sa UsdPrim::GetAppliedSchemas() - /// \sa UsdPrim::HasAPI() - /// \sa UsdPrim::CanApplyAPI() - /// \sa UsdPrim::ApplyAPI() - /// \sa UsdPrim::RemoveAPI() - /// - MJCPHYSICS_API - static MjcPhysicsActuatorAPI Apply(const UsdPrim &prim); + static MjcPhysicsTransmission Define(const UsdStagePtr &stage, + const SdfPath &path); protected: /// Returns the kind of schema this class belongs to. @@ -147,6 +137,30 @@ class MjcPhysicsActuatorAPI : public UsdAPISchemaBase { MJCPHYSICS_API const TfType &_GetTfType() const override; + public: + // --------------------------------------------------------------------- // + // GROUP + // --------------------------------------------------------------------- // + /// Integer MuJoCo group to which the transmission belongs. + /// + /// | || + /// | -- | -- | + /// | Declaration | `uniform int mjc:group = 0` | + /// | C++ Type | int | + /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | + /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | + MJCPHYSICS_API + UsdAttribute GetGroupAttr() const; + + /// See GetGroupAttr(), and also + /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. + /// If specified, author \p defaultValue as the attribute's default, + /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - + /// the default for \p writeSparsely is \c false. + MJCPHYSICS_API + UsdAttribute CreateGroupAttr(VtValue const &defaultValue = VtValue(), + bool writeSparsely = false) const; + public: // --------------------------------------------------------------------- // // MJCCTRLLIMITED @@ -750,6 +764,20 @@ class MjcPhysicsActuatorAPI : public UsdAPISchemaBase { UsdAttribute CreateMjcActEarlyAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely = false) const; + public: + // --------------------------------------------------------------------- // + // MJCTARGET + // --------------------------------------------------------------------- // + /// Actuator transmission target. + /// + MJCPHYSICS_API + UsdRelationship GetMjcTargetRel() const; + + /// See GetMjcTargetRel(), and also + /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create + MJCPHYSICS_API + UsdRelationship CreateMjcTargetRel() const; + public: // --------------------------------------------------------------------- // // MJCREFSITE diff --git a/src/experimental/usd/CMakeLists.txt b/src/experimental/usd/CMakeLists.txt index f0892328..a7d5ae1e 100644 --- a/src/experimental/usd/CMakeLists.txt +++ b/src/experimental/usd/CMakeLists.txt @@ -172,7 +172,6 @@ target_include_directories(${MJCF_PLUGIN_TARGET_NAME} PRIVATE add_library(${MJC_PHYSICS_PLUGIN_TARGET_NAME} SHARED) target_sources(${MJC_PHYSICS_PLUGIN_TARGET_NAME} PRIVATE - mjcPhysics/actuatorAPI.cpp mjcPhysics/collisionAPI.cpp mjcPhysics/jointAPI.cpp mjcPhysics/keyframe.cpp @@ -180,6 +179,7 @@ target_sources(${MJC_PHYSICS_PLUGIN_TARGET_NAME} PRIVATE mjcPhysics/sceneAPI.cpp mjcPhysics/siteAPI.cpp mjcPhysics/tokens.cpp + mjcPhysics/transmission.cpp ) set_target_properties(${MJC_PHYSICS_PLUGIN_TARGET_NAME} PROPERTIES OUTPUT_NAME ${MJC_PHYSICS_PLUGIN_TARGET_NAME} diff --git a/src/experimental/usd/mjcPhysics/generatedSchema.usda b/src/experimental/usd/mjcPhysics/generatedSchema.usda index d8fb8ff6..0fafcead 100644 --- a/src/experimental/usd/mjcPhysics/generatedSchema.usda +++ b/src/experimental/usd/mjcPhysics/generatedSchema.usda @@ -251,8 +251,8 @@ class "MjcMeshCollisionAPI" ( ) } -class "MjcActuatorAPI" ( - doc = "API describing a Mujoco actuator." +class MjcTransmission "MjcTransmission" ( + doc = "Known as actuator in MuJoCo, this prim represents force transmission to joints, bodies, or sites." ) { uniform int mjc:actDim = -1 ( @@ -333,6 +333,9 @@ class "MjcActuatorAPI" ( rel mjc:sliderSite ( doc = "Used only for the slider-crank transmission type. The target site is the pin joining the slider and the connecting rod. The slider moves along the z-axis of the slidersite frame. Therefore the site should be oriented as needed when it is defined in the kinematic tree; its orientation cannot be changed in the actuator definition." ) + rel mjc:target ( + doc = "Actuator transmission target." + ) } class MjcKeyframe "MjcKeyframe" ( diff --git a/src/experimental/usd/mjcPhysics/plugInfo.json b/src/experimental/usd/mjcPhysics/plugInfo.json index 9292c7fa..6db3e021 100644 --- a/src/experimental/usd/mjcPhysics/plugInfo.json +++ b/src/experimental/usd/mjcPhysics/plugInfo.json @@ -3,16 +3,6 @@ { "Info": { "Types": { - "MjcPhysicsActuatorAPI": { - "alias": { - "UsdSchemaBase": "MjcActuatorAPI" - }, - "autoGenerated": true, - "bases": [ - "UsdAPISchemaBase" - ], - "schemaKind": "singleApplyAPI" - }, "MjcPhysicsCollisionAPI": { "alias": { "UsdSchemaBase": "MjcCollisionAPI" @@ -72,6 +62,16 @@ "UsdAPISchemaBase" ], "schemaKind": "singleApplyAPI" + }, + "MjcPhysicsTransmission": { + "alias": { + "UsdSchemaBase": "MjcTransmission" + }, + "autoGenerated": true, + "bases": [ + "UsdTyped" + ], + "schemaKind": "concreteTyped" } } }, diff --git a/src/experimental/usd/mjcPhysics/schema.usda b/src/experimental/usd/mjcPhysics/schema.usda index 5537d7a5..7fe2874e 100644 --- a/src/experimental/usd/mjcPhysics/schema.usda +++ b/src/experimental/usd/mjcPhysics/schema.usda @@ -569,16 +569,20 @@ class "MjcMeshCollisionAPI" ) } -class "MjcActuatorAPI" +class MjcTransmission "MjcTransmission" ( customData = { - string className = "ActuatorAPI" + string className = "Transmission" } - doc = """API describing a Mujoco actuator.""" + doc = """Known as actuator in MuJoCo, this prim represents force transmission to joints, bodies, or sites.""" - inherits = + inherits = ) { + rel mjc:target ( + doc = "Actuator transmission target." + ) + # Control/Force/Activation Limits uniform token mjc:ctrlLimited = "auto" ( doc = "If true, the control input to this actuator is automatically clamped to ctrlrange at runtime. If false, control input clamping is disabled. If 'auto' and autolimits is set in compiler, control clamping will automatically be set to true if ctrlrange is defined without explicitly setting this attribute to 'true'. Note that control input clamping can also be globally disabled with the clampctrl attribute of option/flag." diff --git a/src/experimental/usd/mjcPhysics/tokens.cpp b/src/experimental/usd/mjcPhysics/tokens.cpp index 433ed2f1..388c4628 100644 --- a/src/experimental/usd/mjcPhysics/tokens.cpp +++ b/src/experimental/usd/mjcPhysics/tokens.cpp @@ -134,6 +134,7 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() mjcSpringdamper("mjc:springdamper", TfToken::Immortal), mjcSpringref("mjc:springref", TfToken::Immortal), mjcStiffness("mjc:stiffness", TfToken::Immortal), + mjcTarget("mjc:target", TfToken::Immortal), muscle("muscle", TfToken::Immortal), newton("newton", TfToken::Immortal), none("none", TfToken::Immortal), @@ -144,13 +145,13 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() sparse("sparse", TfToken::Immortal), true_("true", TfToken::Immortal), user("user", TfToken::Immortal), - MjcActuatorAPI("MjcActuatorAPI", TfToken::Immortal), MjcCollisionAPI("MjcCollisionAPI", TfToken::Immortal), MjcJointAPI("MjcJointAPI", TfToken::Immortal), MjcKeyframe("MjcKeyframe", TfToken::Immortal), MjcMeshCollisionAPI("MjcMeshCollisionAPI", TfToken::Immortal), MjcSceneAPI("MjcSceneAPI", TfToken::Immortal), MjcSiteAPI("MjcSiteAPI", TfToken::Immortal), + MjcTransmission("MjcTransmission", TfToken::Immortal), allTokens({affine, auto_, cg, @@ -265,6 +266,7 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() mjcSpringdamper, mjcSpringref, mjcStiffness, + mjcTarget, muscle, newton, none, @@ -275,13 +277,13 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() sparse, true_, user, - MjcActuatorAPI, MjcCollisionAPI, MjcJointAPI, MjcKeyframe, MjcMeshCollisionAPI, MjcSceneAPI, - MjcSiteAPI}) {} + MjcSiteAPI, + MjcTransmission}) {} TfStaticData MjcPhysicsTokens; diff --git a/src/experimental/usd/mjcPhysics/actuatorAPI.cpp b/src/experimental/usd/mjcPhysics/transmission.cpp similarity index 60% rename from src/experimental/usd/mjcPhysics/actuatorAPI.cpp rename to src/experimental/usd/mjcPhysics/transmission.cpp index 830226a9..35350632 100644 --- a/src/experimental/usd/mjcPhysics/actuatorAPI.cpp +++ b/src/experimental/usd/mjcPhysics/transmission.cpp @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include +#include #include #include @@ -23,313 +23,338 @@ PXR_NAMESPACE_OPEN_SCOPE // Register the schema with the TfType system. TF_REGISTRY_FUNCTION(TfType) { - TfType::Define >(); + TfType::Define >(); + + // Register the usd prim typename as an alias under UsdSchemaBase. This + // enables one to call + // TfType::Find().FindDerivedByName("MjcTransmission") + // to find TfType, which is how IsA queries are + // answered. + TfType::AddAlias("MjcTransmission"); } /* virtual */ -MjcPhysicsActuatorAPI::~MjcPhysicsActuatorAPI() {} +MjcPhysicsTransmission::~MjcPhysicsTransmission() {} /* static */ -MjcPhysicsActuatorAPI MjcPhysicsActuatorAPI::Get(const UsdStagePtr &stage, - const SdfPath &path) { +MjcPhysicsTransmission MjcPhysicsTransmission::Get(const UsdStagePtr &stage, + const SdfPath &path) { if (!stage) { TF_CODING_ERROR("Invalid stage"); - return MjcPhysicsActuatorAPI(); + return MjcPhysicsTransmission(); } - return MjcPhysicsActuatorAPI(stage->GetPrimAtPath(path)); + return MjcPhysicsTransmission(stage->GetPrimAtPath(path)); +} + +/* static */ +MjcPhysicsTransmission MjcPhysicsTransmission::Define(const UsdStagePtr &stage, + const SdfPath &path) { + static TfToken usdPrimTypeName("MjcTransmission"); + if (!stage) { + TF_CODING_ERROR("Invalid stage"); + return MjcPhysicsTransmission(); + } + return MjcPhysicsTransmission(stage->DefinePrim(path, usdPrimTypeName)); } /* virtual */ -UsdSchemaKind MjcPhysicsActuatorAPI::_GetSchemaKind() const { - return MjcPhysicsActuatorAPI::schemaKind; +UsdSchemaKind MjcPhysicsTransmission::_GetSchemaKind() const { + return MjcPhysicsTransmission::schemaKind; } /* static */ -bool MjcPhysicsActuatorAPI::CanApply(const UsdPrim &prim, std::string *whyNot) { - return prim.CanApplyAPI(whyNot); -} - -/* static */ -MjcPhysicsActuatorAPI MjcPhysicsActuatorAPI::Apply(const UsdPrim &prim) { - if (prim.ApplyAPI()) { - return MjcPhysicsActuatorAPI(prim); - } - return MjcPhysicsActuatorAPI(); -} - -/* static */ -const TfType &MjcPhysicsActuatorAPI::_GetStaticTfType() { - static TfType tfType = TfType::Find(); +const TfType &MjcPhysicsTransmission::_GetStaticTfType() { + static TfType tfType = TfType::Find(); return tfType; } /* static */ -bool MjcPhysicsActuatorAPI::_IsTypedSchema() { +bool MjcPhysicsTransmission::_IsTypedSchema() { static bool isTyped = _GetStaticTfType().IsA(); return isTyped; } /* virtual */ -const TfType &MjcPhysicsActuatorAPI::_GetTfType() const { +const TfType &MjcPhysicsTransmission::_GetTfType() const { return _GetStaticTfType(); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcCtrlLimitedAttr() const { +UsdAttribute MjcPhysicsTransmission::GetGroupAttr() const { + return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGroup); +} + +UsdAttribute MjcPhysicsTransmission::CreateGroupAttr( + VtValue const &defaultValue, bool writeSparsely) const { + return UsdSchemaBase::_CreateAttr( + MjcPhysicsTokens->mjcGroup, SdfValueTypeNames->Int, + /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); +} + +UsdAttribute MjcPhysicsTransmission::GetMjcCtrlLimitedAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCtrlLimited); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcCtrlLimitedAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcCtrlLimitedAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCtrlLimited, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcForceLimitedAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcForceLimitedAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcForceLimited); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcForceLimitedAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcForceLimitedAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcForceLimited, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcActLimitedAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcActLimitedAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActLimited); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcActLimitedAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcActLimitedAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActLimited, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcCtrlRangeMinAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcCtrlRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCtrlRangeMin); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcCtrlRangeMinAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcCtrlRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCtrlRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcCtrlRangeMaxAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcCtrlRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCtrlRangeMax); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcCtrlRangeMaxAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcCtrlRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCtrlRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcForceRangeMinAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcForceRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcForceRangeMin); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcForceRangeMinAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcForceRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcForceRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcForceRangeMaxAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcForceRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcForceRangeMax); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcForceRangeMaxAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcForceRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcForceRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcActRangeMinAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcActRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActRangeMin); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcActRangeMinAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcActRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcActRangeMaxAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcActRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActRangeMax); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcActRangeMaxAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcActRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcLengthRangeMinAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcLengthRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcLengthRangeMin); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcLengthRangeMinAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcLengthRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcLengthRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcLengthRangeMaxAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcLengthRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcLengthRangeMax); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcLengthRangeMaxAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcLengthRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcLengthRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcGearAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcGearAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGear); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcGearAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcGearAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcGear, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcCrankLengthAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcCrankLengthAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCrankLength); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcCrankLengthAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcCrankLengthAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCrankLength, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcJointInParentAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcJointInParentAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcJointInParent); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcJointInParentAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcJointInParentAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcJointInParent, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcActDimAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcActDimAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActDim); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcActDimAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcActDimAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActDim, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcDynTypeAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcDynTypeAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcDynType); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcDynTypeAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcDynTypeAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcDynType, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcGainTypeAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcGainTypeAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGainType); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcGainTypeAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcGainTypeAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcGainType, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcBiasTypeAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcBiasTypeAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcBiasType); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcBiasTypeAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcBiasTypeAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcBiasType, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcDynPrmAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcDynPrmAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcDynPrm); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcDynPrmAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcDynPrmAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcDynPrm, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcGainPrmAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcGainPrmAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGainPrm); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcGainPrmAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcGainPrmAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcGainPrm, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcBiasPrmAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcBiasPrmAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcBiasPrm); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcBiasPrmAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcBiasPrmAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcBiasPrm, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsActuatorAPI::GetMjcActEarlyAttr() const { +UsdAttribute MjcPhysicsTransmission::GetMjcActEarlyAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActEarly); } -UsdAttribute MjcPhysicsActuatorAPI::CreateMjcActEarlyAttr( +UsdAttribute MjcPhysicsTransmission::CreateMjcActEarlyAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActEarly, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdRelationship MjcPhysicsActuatorAPI::GetMjcRefSiteRel() const { +UsdRelationship MjcPhysicsTransmission::GetMjcTargetRel() const { + return GetPrim().GetRelationship(MjcPhysicsTokens->mjcTarget); +} + +UsdRelationship MjcPhysicsTransmission::CreateMjcTargetRel() const { + return GetPrim().CreateRelationship(MjcPhysicsTokens->mjcTarget, + /* custom = */ false); +} + +UsdRelationship MjcPhysicsTransmission::GetMjcRefSiteRel() const { return GetPrim().GetRelationship(MjcPhysicsTokens->mjcRefSite); } -UsdRelationship MjcPhysicsActuatorAPI::CreateMjcRefSiteRel() const { +UsdRelationship MjcPhysicsTransmission::CreateMjcRefSiteRel() const { return GetPrim().CreateRelationship(MjcPhysicsTokens->mjcRefSite, /* custom = */ false); } -UsdRelationship MjcPhysicsActuatorAPI::GetMjcSliderSiteRel() const { +UsdRelationship MjcPhysicsTransmission::GetMjcSliderSiteRel() const { return GetPrim().GetRelationship(MjcPhysicsTokens->mjcSliderSite); } -UsdRelationship MjcPhysicsActuatorAPI::CreateMjcSliderSiteRel() const { +UsdRelationship MjcPhysicsTransmission::CreateMjcSliderSiteRel() const { return GetPrim().CreateRelationship(MjcPhysicsTokens->mjcSliderSite, /* custom = */ false); } @@ -346,23 +371,24 @@ static inline TfTokenVector _ConcatenateAttributeNames( } // namespace /*static*/ -const TfTokenVector &MjcPhysicsActuatorAPI::GetSchemaAttributeNames( +const TfTokenVector &MjcPhysicsTransmission::GetSchemaAttributeNames( bool includeInherited) { static TfTokenVector localNames = { - MjcPhysicsTokens->mjcCtrlLimited, MjcPhysicsTokens->mjcForceLimited, - MjcPhysicsTokens->mjcActLimited, MjcPhysicsTokens->mjcCtrlRangeMin, - MjcPhysicsTokens->mjcCtrlRangeMax, MjcPhysicsTokens->mjcForceRangeMin, - MjcPhysicsTokens->mjcForceRangeMax, MjcPhysicsTokens->mjcActRangeMin, - MjcPhysicsTokens->mjcActRangeMax, MjcPhysicsTokens->mjcLengthRangeMin, - MjcPhysicsTokens->mjcLengthRangeMax, MjcPhysicsTokens->mjcGear, - MjcPhysicsTokens->mjcCrankLength, MjcPhysicsTokens->mjcJointInParent, - MjcPhysicsTokens->mjcActDim, MjcPhysicsTokens->mjcDynType, - MjcPhysicsTokens->mjcGainType, MjcPhysicsTokens->mjcBiasType, - MjcPhysicsTokens->mjcDynPrm, MjcPhysicsTokens->mjcGainPrm, - MjcPhysicsTokens->mjcBiasPrm, MjcPhysicsTokens->mjcActEarly, + MjcPhysicsTokens->mjcGroup, MjcPhysicsTokens->mjcCtrlLimited, + MjcPhysicsTokens->mjcForceLimited, MjcPhysicsTokens->mjcActLimited, + MjcPhysicsTokens->mjcCtrlRangeMin, MjcPhysicsTokens->mjcCtrlRangeMax, + MjcPhysicsTokens->mjcForceRangeMin, MjcPhysicsTokens->mjcForceRangeMax, + MjcPhysicsTokens->mjcActRangeMin, MjcPhysicsTokens->mjcActRangeMax, + MjcPhysicsTokens->mjcLengthRangeMin, MjcPhysicsTokens->mjcLengthRangeMax, + MjcPhysicsTokens->mjcGear, MjcPhysicsTokens->mjcCrankLength, + MjcPhysicsTokens->mjcJointInParent, MjcPhysicsTokens->mjcActDim, + MjcPhysicsTokens->mjcDynType, MjcPhysicsTokens->mjcGainType, + MjcPhysicsTokens->mjcBiasType, MjcPhysicsTokens->mjcDynPrm, + MjcPhysicsTokens->mjcGainPrm, MjcPhysicsTokens->mjcBiasPrm, + MjcPhysicsTokens->mjcActEarly, }; static TfTokenVector allNames = _ConcatenateAttributeNames( - UsdAPISchemaBase::GetSchemaAttributeNames(true), localNames); + UsdTyped::GetSchemaAttributeNames(true), localNames); if (includeInherited) return allNames; diff --git a/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc b/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc index 86c0fa9f..d4539c93 100644 --- a/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc +++ b/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc @@ -86,6 +86,7 @@ TF_DEFINE_PRIVATE_TOKENS(kTokens, ((materialsScope, "Materials")) ((previewSurface, "PreviewSurface")) ((keyframesScope, "Keyframes")) + ((transmissionsScope, "Transmissions")) ((keyframe, "Keyframe")) ((surface, "PreviewSurface")) ((world, "World")) @@ -210,7 +211,7 @@ class ModelWriter { WriteMaterials(); WriteBodies(); if (write_physics_) { - WriteActuators(); + WriteTransmissions(); } WriteKeyframes(); } @@ -1050,27 +1051,39 @@ class ModelWriter { } } - void WriteActuator(mjsActuator *actuator) { - pxr::SdfPath transmission_path; + void WriteTransmission(mjsActuator *actuator, + const pxr::SdfPath &parent_path) { + pxr::TfToken valid_name = GetValidPrimName(*mjs_getName(actuator->element)); + pxr::SdfPath transmission_path = parent_path.AppendChild(valid_name); + if (!data_->HasSpec(transmission_path)) { + CreatePrimSpec(data_, parent_path, valid_name, + pxr::MjcPhysicsTokens->MjcTransmission); + } + + pxr::SdfPath target_path; if (actuator->trntype == mjtTrn::mjTRN_BODY) { int body_id = mj_name2id(model_, mjOBJ_BODY, actuator->target->c_str()); - transmission_path = body_paths_[body_id]; + target_path = body_paths_[body_id]; } else if (actuator->trntype == mjtTrn::mjTRN_SITE || actuator->trntype == mjtTrn::mjTRN_SLIDERCRANK) { int site_id = mj_name2id(model_, mjOBJ_SITE, actuator->target->c_str()); - transmission_path = site_paths_[site_id]; + target_path = site_paths_[site_id]; } else if (actuator->trntype == mjtTrn::mjTRN_JOINT) { int joint_id = mj_name2id(model_, mjOBJ_JOINT, actuator->target->c_str()); - transmission_path = joint_paths_[joint_id]; + target_path = joint_paths_[joint_id]; } else { TF_WARN(UnsupportedActuatorTypeError, - "Unsupported actuator type for actuator %d", + "Unsupported transmission type for actuator %d", mjs_getId(actuator->element)); return; } - ApplyApiSchema(data_, transmission_path, - MjcPhysicsTokens->MjcActuatorAPI); + CreateRelationshipSpec(data_, transmission_path, + MjcPhysicsTokens->mjcTarget, target_path, + pxr::SdfVariabilityUniform); + + WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Int, + MjcPhysicsTokens->mjcGroup, actuator->group); if (!actuator->refsite->empty()) { int refsite_id = @@ -1190,11 +1203,14 @@ class ModelWriter { pxr::VtDoubleArray(actuator->biasprm, actuator->biasprm + 10)); } - void WriteActuators() { + void WriteTransmissions() { + pxr::SdfPath scope_path = + CreatePrimSpec(data_, body_paths_[kWorldIndex], + kTokens->transmissionsScope, pxr::UsdGeomTokens->Scope); mjsActuator *actuator = mjs_asActuator(mjs_firstElement(spec_, mjOBJ_ACTUATOR)); while (actuator) { - WriteActuator(actuator); + WriteTransmission(actuator, scope_path); actuator = mjs_asActuator(mjs_nextElement(spec_, actuator->element)); } } diff --git a/src/experimental/usd/usd_to_mjspec.cc b/src/experimental/usd/usd_to_mjspec.cc index 394965b2..f9134c98 100644 --- a/src/experimental/usd/usd_to_mjspec.cc +++ b/src/experimental/usd/usd_to_mjspec.cc @@ -21,7 +21,6 @@ #include #include -#include #include #include #include @@ -29,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -553,19 +553,46 @@ void ParseMjcPhysicsMeshCollisionAPI( } } -void ParseMjcPhysicsGeneralActuatorAPI(mjSpec* spec, - const pxr::MjcPhysicsActuatorAPI& act, - mjtTrn tran_type, - const std::string* name) { - pxr::UsdPrim prim = act.GetPrim(); +void ParseMjcPhysicsTransmission(mjSpec* spec, + const pxr::MjcPhysicsTransmission& tran) { + pxr::UsdPrim prim = tran.GetPrim(); mjsActuator* mj_act = mjs_addActuator(spec, nullptr); mjs_setName(mj_act->element, prim.GetPath().GetAsString().c_str()); - mjs_setString(mj_act->target, name->c_str()); - mj_act->trntype = tran_type; - if (tran_type == mjtTrn::mjTRN_SLIDERCRANK) { + auto group_attr = tran.GetGroupAttr(); + if (group_attr.HasAuthoredValue()) { + group_attr.Get(&mj_act->group); + } + + pxr::SdfPathVector targets; + tran.GetMjcTargetRel().GetTargets(&targets); + if (targets.empty()) { + mju_warning("Transmission %s has no target, skipping.", + prim.GetPath().GetAsString().c_str()); + return; + } + if (targets.size() > 1) { + mju_warning("Transmission has more than one target, using the first."); + } + mjs_setString(mj_act->target, targets[0].GetAsString().c_str()); + + auto target_prim = prim.GetStage()->GetPrimAtPath(targets[0]); + bool slider_crank = tran.GetMjcSliderSiteRel().HasAuthoredTargets(); + if (target_prim.IsA()) { + mj_act->trntype = mjTRN_JOINT; + } else if (target_prim.HasAPI()) { + mj_act->trntype = mjTRN_BODY; + } else if (target_prim.HasAPI()) { + mj_act->trntype = slider_crank ? mjTRN_SLIDERCRANK : mjTRN_SITE; + } else { + mju_warning("Transmission %s has an invalid target type, skipping.", + prim.GetPath().GetAsString().c_str()); + return; + } + + if (slider_crank) { pxr::SdfPathVector slider_sites; - act.GetMjcSliderSiteRel().GetTargets(&slider_sites); + tran.GetMjcSliderSiteRel().GetTargets(&slider_sites); if (slider_sites.size() > 1) { mju_warning( "Slider crank slider site relationship has more than one target, " @@ -590,9 +617,9 @@ void ParseMjcPhysicsGeneralActuatorAPI(mjSpec* spec, } }; - setLimitedField(mj_act, act.GetMjcCtrlLimitedAttr(), &mj_act->ctrllimited); - setLimitedField(mj_act, act.GetMjcForceLimitedAttr(), &mj_act->forcelimited); - setLimitedField(mj_act, act.GetMjcActLimitedAttr(), &mj_act->actlimited); + setLimitedField(mj_act, tran.GetMjcCtrlLimitedAttr(), &mj_act->ctrllimited); + setLimitedField(mj_act, tran.GetMjcForceLimitedAttr(), &mj_act->forcelimited); + setLimitedField(mj_act, tran.GetMjcActLimitedAttr(), &mj_act->actlimited); auto setRangeField = [](mjsActuator* mj_act, const pxr::UsdAttribute& usd_min_attribute, @@ -609,16 +636,16 @@ void ParseMjcPhysicsGeneralActuatorAPI(mjSpec* spec, } }; - setRangeField(mj_act, act.GetMjcCtrlRangeMinAttr(), - act.GetMjcCtrlRangeMaxAttr(), mj_act->ctrlrange); - setRangeField(mj_act, act.GetMjcForceRangeMinAttr(), - act.GetMjcForceRangeMaxAttr(), mj_act->forcerange); - setRangeField(mj_act, act.GetMjcActRangeMinAttr(), - act.GetMjcActRangeMaxAttr(), mj_act->actrange); - setRangeField(mj_act, act.GetMjcLengthRangeMinAttr(), - act.GetMjcLengthRangeMaxAttr(), mj_act->lengthrange); + setRangeField(mj_act, tran.GetMjcCtrlRangeMinAttr(), + tran.GetMjcCtrlRangeMaxAttr(), mj_act->ctrlrange); + setRangeField(mj_act, tran.GetMjcForceRangeMinAttr(), + tran.GetMjcForceRangeMaxAttr(), mj_act->forcerange); + setRangeField(mj_act, tran.GetMjcActRangeMinAttr(), + tran.GetMjcActRangeMaxAttr(), mj_act->actrange); + setRangeField(mj_act, tran.GetMjcLengthRangeMinAttr(), + tran.GetMjcLengthRangeMaxAttr(), mj_act->lengthrange); - auto gear_attr = act.GetMjcGearAttr(); + auto gear_attr = tran.GetMjcGearAttr(); if (gear_attr.HasAuthoredValue()) { pxr::VtDoubleArray gear; gear_attr.Get(&gear); @@ -627,14 +654,14 @@ void ParseMjcPhysicsGeneralActuatorAPI(mjSpec* spec, } } - auto crank_length_attr = act.GetMjcCrankLengthAttr(); + auto crank_length_attr = tran.GetMjcCrankLengthAttr(); if (crank_length_attr.HasAuthoredValue()) { double crank_length; crank_length_attr.Get(&crank_length); mj_act->cranklength = crank_length; } - auto dyn_type_attr = act.GetMjcDynTypeAttr(); + auto dyn_type_attr = tran.GetMjcDynTypeAttr(); if (dyn_type_attr.HasAuthoredValue()) { pxr::TfToken dyn_type; dyn_type_attr.Get(&dyn_type); @@ -653,7 +680,7 @@ void ParseMjcPhysicsGeneralActuatorAPI(mjSpec* spec, } } - auto gain_type_attr = act.GetMjcGainTypeAttr(); + auto gain_type_attr = tran.GetMjcGainTypeAttr(); if (gain_type_attr.HasAuthoredValue()) { pxr::TfToken gain_type; gain_type_attr.Get(&gain_type); @@ -668,7 +695,7 @@ void ParseMjcPhysicsGeneralActuatorAPI(mjSpec* spec, } } - auto biastype_attr = act.GetMjcBiasTypeAttr(); + auto biastype_attr = tran.GetMjcBiasTypeAttr(); if (biastype_attr.HasAuthoredValue()) { pxr::TfToken biastype; biastype_attr.Get(&biastype); @@ -695,25 +722,25 @@ void ParseMjcPhysicsGeneralActuatorAPI(mjSpec* spec, } }; - setPrmField(mj_act, act.GetMjcDynPrmAttr(), mj_act->dynprm); - setPrmField(mj_act, act.GetMjcBiasPrmAttr(), mj_act->biasprm); - setPrmField(mj_act, act.GetMjcGainPrmAttr(), mj_act->gainprm); + setPrmField(mj_act, tran.GetMjcDynPrmAttr(), mj_act->dynprm); + setPrmField(mj_act, tran.GetMjcBiasPrmAttr(), mj_act->biasprm); + setPrmField(mj_act, tran.GetMjcGainPrmAttr(), mj_act->gainprm); - auto act_dim_attr = act.GetMjcActDimAttr(); + auto act_dim_attr = tran.GetMjcActDimAttr(); if (act_dim_attr.HasAuthoredValue()) { int act_dim; act_dim_attr.Get(&act_dim); mj_act->actdim = act_dim; } - auto act_early_attr = act.GetMjcActEarlyAttr(); + auto act_early_attr = tran.GetMjcActEarlyAttr(); if (act_early_attr.HasAuthoredValue()) { bool act_early; act_early_attr.Get(&act_early); mj_act->actearly = (int)act_early; } - auto ref_site_rel = act.GetMjcRefSiteRel(); + auto ref_site_rel = tran.GetMjcRefSiteRel(); if (ref_site_rel.HasAuthoredTargets()) { pxr::SdfPathVector targets; ref_site_rel.GetTargets(&targets); @@ -1126,12 +1153,6 @@ void ParseUsdPhysicsJoint(mjSpec* spec, const pxr::UsdPrim& prim, mjsBody* body, SetDoubleArrFromGfVec3d(mj_joint->axis, rotated_axis); } - if (prim.HasAPI()) { - ParseMjcPhysicsGeneralActuatorAPI(spec, pxr::MjcPhysicsActuatorAPI(prim), - mjtTrn::mjTRN_JOINT, - mjs_getName(mj_joint->element)); - } - if (prim.HasAPI()) { ParseMjcPhysicsJointAPI(mj_joint, pxr::MjcPhysicsJointAPI(prim)); } @@ -1152,15 +1173,6 @@ void ParseMjcPhysicsSite(mjSpec* spec, const pxr::MjcPhysicsSiteAPI& site_api, prim.GetTypeName().GetString().c_str()); return; } - - if (prim.HasAPI()) { - auto act_api = pxr::MjcPhysicsActuatorAPI(prim); - bool slider_crank = act_api.GetMjcSliderSiteRel().HasAuthoredTargets(); - ParseMjcPhysicsGeneralActuatorAPI( - spec, pxr::MjcPhysicsActuatorAPI(prim), - slider_crank ? mjtTrn::mjTRN_SLIDERCRANK : mjtTrn::mjTRN_SITE, - mjs_getName(site->element)); - } } void ParseMjcPhysicsKeyframe(mjSpec* spec, @@ -1236,12 +1248,6 @@ mjsBody* ParseUsdPhysicsRigidbody( ParseUsdPhysicsMassAPIForBody(body, pxr::UsdPhysicsMassAPI(prim)); } - if (prim.HasAPI()) { - ParseMjcPhysicsGeneralActuatorAPI(spec, pxr::MjcPhysicsActuatorAPI(prim), - mjtTrn::mjTRN_BODY, - mjs_getName(body->element)); - } - mujoco::usd::SetUsdPrimPathUserValue(body->element, prim.GetPath()); return body; @@ -1423,6 +1429,10 @@ mjSpec* mj_parseUSDStage(const pxr::UsdStageRefPtr stage) { } else if (prim.IsA()) { ParseMjcPhysicsKeyframe(spec, pxr::MjcPhysicsKeyframe(prim)); + it.PruneChildren(); + } else if (prim.IsA()) { + ParseMjcPhysicsTransmission(spec, pxr::MjcPhysicsTransmission(prim)); + it.PruneChildren(); } } @@ -1443,11 +1453,3 @@ mjSpec* mj_parseUSDStage(const pxr::UsdStageRefPtr stage) { return spec; } -mjSpec* mj_parseUSDStage(const char* usd_path) { - pxr::UsdStageRefPtr stage = pxr::UsdStage::Open(usd_path); - if (!stage) { - mju_error("Could not open USD stage: %s", usd_path); - return nullptr; - } - return mj_parseUSDStage(stage); -} diff --git a/test/experimental/usd/plugins/mjcf/mjcf_file_format_test.cc b/test/experimental/usd/plugins/mjcf/mjcf_file_format_test.cc index 17204cf2..a9070179 100644 --- a/test/experimental/usd/plugins/mjcf/mjcf_file_format_test.cc +++ b/test/experimental/usd/plugins/mjcf/mjcf_file_format_test.cc @@ -18,13 +18,13 @@ #include #include -#include #include #include #include #include #include #include +#include #include "test/experimental/usd/test_utils.h" #include "test/fixture.h" #include @@ -1525,7 +1525,7 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMassAPIDensity) { ExpectAttributeEqual(stage, "/test/body/box.physics:density", 1234.0f); } -TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsActuatorGeneral) { +TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsTransmission) { static constexpr char xml[] = R"( @@ -1562,37 +1562,50 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsActuatorGeneral) { )"; auto stage = OpenStageWithPhysics(xml); - EXPECT_PRIM_API_APPLIED(stage, "/test/body/site", pxr::MjcPhysicsActuatorAPI); - EXPECT_REL_HAS_TARGET(stage, "/test/body/site.mjc:refSite", "/test/body/ref"); - ExpectAttributeEqual(stage, "/test/body/site.mjc:ctrlLimited", + EXPECT_PRIM_VALID(stage, "/test/Transmissions/general"); + EXPECT_PRIM_IS_A(stage, "/test/Transmissions/general", + pxr::MjcPhysicsTransmission); + EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:target", + "/test/body/site"); + EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:refSite", + "/test/body/ref"); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:ctrlLimited", pxr::MjcPhysicsTokens->true_); - ExpectAttributeEqual(stage, "/test/body/site.mjc:ctrlRange:min", 0.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:ctrlRange:max", 1.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:forceLimited", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:ctrlRange:min", + 0.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:ctrlRange:max", + 1.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:forceLimited", pxr::MjcPhysicsTokens->true_); - ExpectAttributeEqual(stage, "/test/body/site.mjc:forceRange:min", 2.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:forceRange:max", 3.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:actLimited", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:forceRange:min", + 2.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:forceRange:max", + 3.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actLimited", pxr::MjcPhysicsTokens->false_); - ExpectAttributeEqual(stage, "/test/body/site.mjc:actRange:min", 4.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:actRange:max", 5.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:lengthRange:min", 6.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:lengthRange:max", 7.0); - ExpectAttributeEqual(stage, "/test/body/site.mjc:actDim", 1); - ExpectAttributeEqual(stage, "/test/body/site.mjc:dynType", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actRange:min", + 4.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actRange:max", + 5.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:lengthRange:min", + 6.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:lengthRange:max", + 7.0); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actDim", 1); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:dynType", MjcPhysicsTokens->filter); - ExpectAttributeEqual(stage, "/test/body/site.mjc:gainType", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:gainType", MjcPhysicsTokens->user); - ExpectAttributeEqual(stage, "/test/body/site.mjc:biasType", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:biasType", MjcPhysicsTokens->user); - ExpectAttributeEqual(stage, "/test/body/site.mjc:actEarly", true); - ExpectAttributeEqual(stage, "/test/body/site.mjc:gear", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actEarly", true); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:gear", pxr::VtDoubleArray{{1, 2, 3, 4, 5, 6}}); - ExpectAttributeEqual(stage, "/test/body/site.mjc:dynPrm", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:dynPrm", pxr::VtDoubleArray{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}); - ExpectAttributeEqual(stage, "/test/body/site.mjc:gainPrm", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:gainPrm", pxr::VtDoubleArray{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}); - ExpectAttributeEqual(stage, "/test/body/site.mjc:biasPrm", + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:biasPrm", pxr::VtDoubleArray{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}); } @@ -1617,8 +1630,11 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsJointActuator) { )"; auto stage = OpenStageWithPhysics(xml); - EXPECT_PRIM_API_APPLIED(stage, "/test/axle/rod/rod_hinge", - pxr::MjcPhysicsActuatorAPI); + EXPECT_PRIM_VALID(stage, "/test/Transmissions/general"); + EXPECT_PRIM_IS_A(stage, "/test/Transmissions/general", + pxr::MjcPhysicsTransmission); + EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:target", + "/test/axle/rod/rod_hinge"); } TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsBodyActuator) { @@ -1639,7 +1655,11 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsBodyActuator) { )"; auto stage = OpenStageWithPhysics(xml); - EXPECT_PRIM_API_APPLIED(stage, "/test/body", pxr::MjcPhysicsActuatorAPI); + EXPECT_PRIM_VALID(stage, "/test/Transmissions/general"); + EXPECT_PRIM_IS_A(stage, "/test/Transmissions/general", + pxr::MjcPhysicsTransmission); + EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:target", + "/test/body"); } TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsSliderCrankActuator) { @@ -1664,11 +1684,15 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsSliderCrankActuator) { )"; auto stage = OpenStageWithPhysics(xml); - EXPECT_PRIM_API_APPLIED(stage, "/test/body/crank", - pxr::MjcPhysicsActuatorAPI); - EXPECT_REL_HAS_TARGET(stage, "/test/body/crank.mjc:sliderSite", + EXPECT_PRIM_VALID(stage, "/test/Transmissions/general"); + EXPECT_PRIM_IS_A(stage, "/test/Transmissions/general", + pxr::MjcPhysicsTransmission); + EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:target", + "/test/body/crank"); + EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:sliderSite", "/test/body/slider"); - ExpectAttributeEqual(stage, "/test/body/crank.mjc:crankLength", 1.23); + ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:crankLength", + 1.23); } TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsJointAPI) { diff --git a/test/xml/testdata/simple_hinge.usda b/test/xml/testdata/simple_hinge.usda index 9027c91e..739b8265 100644 --- a/test/xml/testdata/simple_hinge.usda +++ b/test/xml/testdata/simple_hinge.usda @@ -36,10 +36,7 @@ def Xform "World" uniform token[] xformOpOrder = ["xformOp:transform"] } - def PhysicsRevoluteJoint "HingeJoint" ( - prepend apiSchemas = ["PhysicsActuatorAPI"] - ) - { + def PhysicsRevoluteJoint "HingeJoint" { rel physics:body0 = rel physics:body1 = point3f physics:localPos0 = (0, 0, 0) @@ -67,5 +64,11 @@ def Xform "World" rel physics:body1 = } } + + def Scope "Transmissions" { + def MjcTransmission "HingeActuator" { + rel mjc:target = + } + } }