From 11e695b4c2af9886ac4415300cca250493d01669 Mon Sep 17 00:00:00 2001 From: Sam Haves Date: Sat, 12 Jul 2025 09:37:55 -0700 Subject: [PATCH] Rename MjcTransmission to MjcActuator in mjcPhysics schema. PiperOrigin-RevId: 782352356 Change-Id: I4b74e3131b0fed925c506742c22038231f848909 --- .../mjcPhysics/{transmission.h => actuator.h} | 37 +++-- .../experimental/usd/mjcPhysics/tokens.h | 116 +++++++------ src/experimental/usd/CMakeLists.txt | 2 +- .../{transmission.cpp => actuator.cpp} | 152 +++++++++--------- .../usd/mjcPhysics/generatedSchema.usda | 2 +- src/experimental/usd/mjcPhysics/plugInfo.json | 20 +-- src/experimental/usd/mjcPhysics/schema.usda | 4 +- src/experimental/usd/mjcPhysics/tokens.cpp | 8 +- .../usd/plugins/mjcf/mujoco_to_usd.cc | 48 +++--- src/experimental/usd/usd_to_mjspec.cc | 16 +- .../usd/plugins/mjcf/mjcf_file_format_test.cc | 84 +++++----- test/xml/testdata/simple_hinge.usda | 4 +- 12 files changed, 243 insertions(+), 250 deletions(-) rename include/mujoco/experimental/usd/mjcPhysics/{transmission.h => actuator.h} (97%) rename src/experimental/usd/mjcPhysics/{transmission.cpp => actuator.cpp} (69%) diff --git a/include/mujoco/experimental/usd/mjcPhysics/transmission.h b/include/mujoco/experimental/usd/mjcPhysics/actuator.h similarity index 97% rename from include/mujoco/experimental/usd/mjcPhysics/transmission.h rename to include/mujoco/experimental/usd/mjcPhysics/actuator.h index 816b1b1b..f32ec693 100644 --- a/include/mujoco/experimental/usd/mjcPhysics/transmission.h +++ b/include/mujoco/experimental/usd/mjcPhysics/actuator.h @@ -12,10 +12,10 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef MJCPHYSICS_GENERATED_TRANSMISSION_H -#define MJCPHYSICS_GENERATED_TRANSMISSION_H +#ifndef MJCPHYSICS_GENERATED_ACTUATOR_H +#define MJCPHYSICS_GENERATED_ACTUATOR_H -/// \file mjcPhysics/transmission.h +/// \file mjcPhysics/actuator.h #include #include @@ -35,10 +35,10 @@ PXR_NAMESPACE_OPEN_SCOPE class SdfAssetPath; // -------------------------------------------------------------------------- // -// MJCTRANSMISSION // +// MJCACTUATOR // // -------------------------------------------------------------------------- // -/// \class MjcPhysicsTransmission +/// \class MjcPhysicsActuator /// /// Known as actuator in MuJoCo, this prim represents force transmission to /// joints, bodies, or sites. @@ -48,29 +48,29 @@ class SdfAssetPath; /// \ref MjcPhysicsTokens. So to set an attribute to the value "rightHanded", /// use MjcPhysicsTokens->rightHanded as the value. /// -class MjcPhysicsTransmission : public UsdTyped { +class MjcPhysicsActuator : public UsdTyped { public: /// Compile time constant representing what kind of schema this class is. /// /// \sa UsdSchemaKind static const UsdSchemaKind schemaKind = UsdSchemaKind::ConcreteTyped; - /// Construct a MjcPhysicsTransmission on UsdPrim \p prim . - /// Equivalent to MjcPhysicsTransmission::Get(prim.GetStage(), prim.GetPath()) + /// Construct a MjcPhysicsActuator on UsdPrim \p prim . + /// Equivalent to MjcPhysicsActuator::Get(prim.GetStage(), prim.GetPath()) /// for a \em valid \p prim, but will not immediately throw an error for /// an invalid \p prim - explicit MjcPhysicsTransmission(const UsdPrim &prim = UsdPrim()) + explicit MjcPhysicsActuator(const UsdPrim &prim = UsdPrim()) : UsdTyped(prim) {} - /// Construct a MjcPhysicsTransmission on the prim held by \p schemaObj . - /// Should be preferred over MjcPhysicsTransmission(schemaObj.GetPrim()), + /// Construct a MjcPhysicsActuator on the prim held by \p schemaObj . + /// Should be preferred over MjcPhysicsActuator(schemaObj.GetPrim()), /// as it preserves SchemaBase state. - explicit MjcPhysicsTransmission(const UsdSchemaBase &schemaObj) + explicit MjcPhysicsActuator(const UsdSchemaBase &schemaObj) : UsdTyped(schemaObj) {} /// Destructor. MJCPHYSICS_API - virtual ~MjcPhysicsTransmission(); + virtual ~MjcPhysicsActuator(); /// Return a vector of names of all pre-declared attributes for this schema /// class and all its ancestor classes. Does not include attributes that @@ -79,18 +79,17 @@ class MjcPhysicsTransmission : public UsdTyped { static const TfTokenVector &GetSchemaAttributeNames( bool includeInherited = true); - /// Return a MjcPhysicsTransmission holding the prim adhering to this + /// Return a MjcPhysicsActuator 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 - /// MjcPhysicsTransmission(stage->GetPrimAtPath(path)); + /// MjcPhysicsActuator(stage->GetPrimAtPath(path)); /// \endcode /// MJCPHYSICS_API - static MjcPhysicsTransmission Get(const UsdStagePtr &stage, - const SdfPath &path); + static MjcPhysicsActuator Get(const UsdStagePtr &stage, const SdfPath &path); /// Attempt to ensure a \a UsdPrim adhering to this schema at \p path /// is defined (according to UsdPrim::IsDefined()) on this stage. @@ -115,8 +114,8 @@ class MjcPhysicsTransmission : public UsdTyped { /// the opinion at the current EditTarget. /// MJCPHYSICS_API - static MjcPhysicsTransmission Define(const UsdStagePtr &stage, - const SdfPath &path); + static MjcPhysicsActuator Define(const UsdStagePtr &stage, + const SdfPath &path); protected: /// Returns the kind of schema this class belongs to. diff --git a/include/mujoco/experimental/usd/mjcPhysics/tokens.h b/include/mujoco/experimental/usd/mjcPhysics/tokens.h index b1db8e82..5d697927 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 MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Possible - /// value for MjcPhysicsTransmission::GetMjcGainTypeAttr() + /// Possible value for MjcPhysicsActuator::GetMjcBiasTypeAttr(), Possible + /// value for MjcPhysicsActuator::GetMjcGainTypeAttr() const TfToken affine; /// \brief "auto" /// /// Fallback value for MjcPhysicsSceneAPI::GetJacobianAttr(), Fallback value - /// for MjcPhysicsTransmission::GetMjcActLimitedAttr(), Fallback value for - /// MjcPhysicsTransmission::GetMjcCtrlLimitedAttr(), Fallback value for - /// MjcPhysicsTransmission::GetMjcForceLimitedAttr(), Fallback value for + /// for MjcPhysicsActuator::GetMjcActLimitedAttr(), Fallback value for + /// MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Fallback value for + /// MjcPhysicsActuator::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 MjcPhysicsTransmission::GetMjcActLimitedAttr(), - /// Possible value for MjcPhysicsTransmission::GetMjcCtrlLimitedAttr(), - /// Possible value for MjcPhysicsTransmission::GetMjcForceLimitedAttr(), - /// Possible value for MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() + /// Possible value for MjcPhysicsActuator::GetMjcActLimitedAttr(), Possible + /// value for MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Possible value for + /// MjcPhysicsActuator::GetMjcForceLimitedAttr(), Possible value for + /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() const TfToken false_; /// \brief "filter" /// - /// Possible value for MjcPhysicsTransmission::GetMjcDynTypeAttr() + /// Possible value for MjcPhysicsActuator::GetMjcDynTypeAttr() const TfToken filter; /// \brief "filterexact" /// - /// Possible value for MjcPhysicsTransmission::GetMjcDynTypeAttr() + /// Possible value for MjcPhysicsActuator::GetMjcDynTypeAttr() const TfToken filterexact; /// \brief "fixed" /// - /// Fallback value for MjcPhysicsTransmission::GetMjcGainTypeAttr() + /// Fallback value for MjcPhysicsActuator::GetMjcGainTypeAttr() const TfToken fixed; /// \brief "implicit" /// @@ -126,7 +126,7 @@ struct MjcPhysicsTokensType { const TfToken implicitfast; /// \brief "integrator" /// - /// Possible value for MjcPhysicsTransmission::GetMjcDynTypeAttr() + /// Possible value for MjcPhysicsActuator::GetMjcDynTypeAttr() const TfToken integrator; /// \brief "legacy" /// @@ -138,23 +138,23 @@ struct MjcPhysicsTokensType { const TfToken mjcAct; /// \brief "mjc:actDim" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcActDim; /// \brief "mjc:actEarly" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcActEarly; /// \brief "mjc:actLimited" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcActLimited; /// \brief "mjc:actRange:max" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcActRangeMax; /// \brief "mjc:actRange:min" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcActRangeMin; /// \brief "mjc:actuatorfrclimited" /// @@ -178,15 +178,15 @@ struct MjcPhysicsTokensType { const TfToken mjcArmature; /// \brief "mjc:biasPrm" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcBiasPrm; /// \brief "mjc:biasType" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcBiasType; /// \brief "mjc:crankLength" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcCrankLength; /// \brief "mjc:ctrl" /// @@ -194,15 +194,15 @@ struct MjcPhysicsTokensType { const TfToken mjcCtrl; /// \brief "mjc:ctrlLimited" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcCtrlLimited; /// \brief "mjc:ctrlRange:max" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcCtrlRangeMax; /// \brief "mjc:ctrlRange:min" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcCtrlRangeMin; /// \brief "mjc:damping" /// @@ -210,11 +210,11 @@ struct MjcPhysicsTokensType { const TfToken mjcDamping; /// \brief "mjc:dynPrm" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcDynPrm; /// \brief "mjc:dynType" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcDynType; /// \brief "mjc:flag:actuation" /// @@ -310,15 +310,15 @@ struct MjcPhysicsTokensType { const TfToken mjcFlagWarmstart; /// \brief "mjc:forceLimited" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcForceLimited; /// \brief "mjc:forceRange:max" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcForceRangeMax; /// \brief "mjc:forceRange:min" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcForceRangeMin; /// \brief "mjc:frictionloss" /// @@ -326,20 +326,20 @@ struct MjcPhysicsTokensType { const TfToken mjcFrictionloss; /// \brief "mjc:gainPrm" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcGainPrm; /// \brief "mjc:gainType" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcGainType; /// \brief "mjc:gear" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcGear; /// \brief "mjc:group" /// - /// MjcPhysicsSiteAPI, MjcPhysicsImageableAPI, MjcPhysicsCollisionAPI, - /// MjcPhysicsTransmission, MjcPhysicsJointAPI + /// MjcPhysicsSiteAPI, MjcPhysicsCollisionAPI, MjcPhysicsActuator, + /// MjcPhysicsJointAPI const TfToken mjcGroup; /// \brief "mjc:inertia" /// @@ -347,15 +347,15 @@ struct MjcPhysicsTokensType { const TfToken mjcInertia; /// \brief "mjc:jointInParent" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcJointInParent; /// \brief "mjc:lengthRange:max" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcLengthRangeMax; /// \brief "mjc:lengthRange:min" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcLengthRangeMin; /// \brief "mjc:margin" /// @@ -491,7 +491,7 @@ struct MjcPhysicsTokensType { const TfToken mjcRef; /// \brief "mjc:refSite" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcRefSite; /// \brief "mjc:shellinertia" /// @@ -499,7 +499,7 @@ struct MjcPhysicsTokensType { const TfToken mjcShellinertia; /// \brief "mjc:sliderSite" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcSliderSite; /// \brief "mjc:solimpfriction" /// @@ -531,13 +531,13 @@ struct MjcPhysicsTokensType { const TfToken mjcStiffness; /// \brief "mjc:target" /// - /// MjcPhysicsTransmission + /// MjcPhysicsActuator const TfToken mjcTarget; /// \brief "muscle" /// - /// Possible value for MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Possible - /// value for MjcPhysicsTransmission::GetMjcDynTypeAttr(), Possible value for - /// MjcPhysicsTransmission::GetMjcGainTypeAttr() + /// Possible value for MjcPhysicsActuator::GetMjcBiasTypeAttr(), Possible + /// value for MjcPhysicsActuator::GetMjcDynTypeAttr(), Possible value for + /// MjcPhysicsActuator::GetMjcGainTypeAttr() const TfToken muscle; /// \brief "newton" /// @@ -546,8 +546,8 @@ struct MjcPhysicsTokensType { const TfToken newton; /// \brief "none" /// - /// Fallback value for MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Fallback - /// value for MjcPhysicsTransmission::GetMjcDynTypeAttr() + /// Fallback value for MjcPhysicsActuator::GetMjcBiasTypeAttr(), Fallback + /// value for MjcPhysicsActuator::GetMjcDynTypeAttr() const TfToken none; /// \brief "pgs" /// @@ -575,25 +575,25 @@ struct MjcPhysicsTokensType { const TfToken sparse; /// \brief "true" /// - /// Possible value for MjcPhysicsTransmission::GetMjcActLimitedAttr(), - /// Possible value for MjcPhysicsTransmission::GetMjcCtrlLimitedAttr(), - /// Possible value for MjcPhysicsTransmission::GetMjcForceLimitedAttr(), - /// Possible value for MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() + /// Possible value for MjcPhysicsActuator::GetMjcActLimitedAttr(), Possible + /// value for MjcPhysicsActuator::GetMjcCtrlLimitedAttr(), Possible value for + /// MjcPhysicsActuator::GetMjcForceLimitedAttr(), Possible value for + /// MjcPhysicsJointAPI::GetMjcActuatorfrclimitedAttr() const TfToken true_; /// \brief "user" /// - /// Possible value for MjcPhysicsTransmission::GetMjcBiasTypeAttr(), Possible - /// value for MjcPhysicsTransmission::GetMjcDynTypeAttr(), Possible value for - /// MjcPhysicsTransmission::GetMjcGainTypeAttr() + /// Possible value for MjcPhysicsActuator::GetMjcBiasTypeAttr(), Possible + /// value for MjcPhysicsActuator::GetMjcDynTypeAttr(), Possible value for + /// MjcPhysicsActuator::GetMjcGainTypeAttr() const TfToken user; + /// \brief "MjcActuator" + /// + /// Schema identifier and family for MjcPhysicsActuator + const TfToken MjcActuator; /// \brief "MjcCollisionAPI" /// /// Schema identifier and family for MjcPhysicsCollisionAPI const TfToken MjcCollisionAPI; - /// \brief "MjcImageableAPI" - /// - /// Schema identifier and family for MjcPhysicsImageableAPI - const TfToken MjcImageableAPI; /// \brief "MjcJointAPI" /// /// Schema identifier and family for MjcPhysicsJointAPI @@ -614,10 +614,6 @@ 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/src/experimental/usd/CMakeLists.txt b/src/experimental/usd/CMakeLists.txt index a7d5ae1e..c3b29730 100644 --- a/src/experimental/usd/CMakeLists.txt +++ b/src/experimental/usd/CMakeLists.txt @@ -172,6 +172,7 @@ 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/actuator.cpp mjcPhysics/collisionAPI.cpp mjcPhysics/jointAPI.cpp mjcPhysics/keyframe.cpp @@ -179,7 +180,6 @@ 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/transmission.cpp b/src/experimental/usd/mjcPhysics/actuator.cpp similarity index 69% rename from src/experimental/usd/mjcPhysics/transmission.cpp rename to src/experimental/usd/mjcPhysics/actuator.cpp index 35350632..34ee3fdf 100644 --- a/src/experimental/usd/mjcPhysics/transmission.cpp +++ b/src/experimental/usd/mjcPhysics/actuator.cpp @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include +#include #include #include @@ -23,338 +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 + // TfType::Find().FindDerivedByName("MjcActuator") + // to find TfType, which is how IsA queries are // answered. - TfType::AddAlias("MjcTransmission"); + TfType::AddAlias("MjcActuator"); } /* virtual */ -MjcPhysicsTransmission::~MjcPhysicsTransmission() {} +MjcPhysicsActuator::~MjcPhysicsActuator() {} /* static */ -MjcPhysicsTransmission MjcPhysicsTransmission::Get(const UsdStagePtr &stage, - const SdfPath &path) { +MjcPhysicsActuator MjcPhysicsActuator::Get(const UsdStagePtr &stage, + const SdfPath &path) { if (!stage) { TF_CODING_ERROR("Invalid stage"); - return MjcPhysicsTransmission(); + return MjcPhysicsActuator(); } - return MjcPhysicsTransmission(stage->GetPrimAtPath(path)); + return MjcPhysicsActuator(stage->GetPrimAtPath(path)); } /* static */ -MjcPhysicsTransmission MjcPhysicsTransmission::Define(const UsdStagePtr &stage, - const SdfPath &path) { - static TfToken usdPrimTypeName("MjcTransmission"); +MjcPhysicsActuator MjcPhysicsActuator::Define(const UsdStagePtr &stage, + const SdfPath &path) { + static TfToken usdPrimTypeName("MjcActuator"); if (!stage) { TF_CODING_ERROR("Invalid stage"); - return MjcPhysicsTransmission(); + return MjcPhysicsActuator(); } - return MjcPhysicsTransmission(stage->DefinePrim(path, usdPrimTypeName)); + return MjcPhysicsActuator(stage->DefinePrim(path, usdPrimTypeName)); } /* virtual */ -UsdSchemaKind MjcPhysicsTransmission::_GetSchemaKind() const { - return MjcPhysicsTransmission::schemaKind; +UsdSchemaKind MjcPhysicsActuator::_GetSchemaKind() const { + return MjcPhysicsActuator::schemaKind; } /* static */ -const TfType &MjcPhysicsTransmission::_GetStaticTfType() { - static TfType tfType = TfType::Find(); +const TfType &MjcPhysicsActuator::_GetStaticTfType() { + static TfType tfType = TfType::Find(); return tfType; } /* static */ -bool MjcPhysicsTransmission::_IsTypedSchema() { +bool MjcPhysicsActuator::_IsTypedSchema() { static bool isTyped = _GetStaticTfType().IsA(); return isTyped; } /* virtual */ -const TfType &MjcPhysicsTransmission::_GetTfType() const { +const TfType &MjcPhysicsActuator::_GetTfType() const { return _GetStaticTfType(); } -UsdAttribute MjcPhysicsTransmission::GetGroupAttr() const { +UsdAttribute MjcPhysicsActuator::GetGroupAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGroup); } -UsdAttribute MjcPhysicsTransmission::CreateGroupAttr( - VtValue const &defaultValue, bool writeSparsely) const { +UsdAttribute MjcPhysicsActuator::CreateGroupAttr(VtValue const &defaultValue, + bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcGroup, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcCtrlLimitedAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcCtrlLimitedAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCtrlLimited); } -UsdAttribute MjcPhysicsTransmission::CreateMjcCtrlLimitedAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcCtrlLimitedAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCtrlLimited, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcForceLimitedAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcForceLimitedAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcForceLimited); } -UsdAttribute MjcPhysicsTransmission::CreateMjcForceLimitedAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcForceLimitedAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcForceLimited, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcActLimitedAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcActLimitedAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActLimited); } -UsdAttribute MjcPhysicsTransmission::CreateMjcActLimitedAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcActLimitedAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActLimited, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcCtrlRangeMinAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcCtrlRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCtrlRangeMin); } -UsdAttribute MjcPhysicsTransmission::CreateMjcCtrlRangeMinAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcCtrlRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCtrlRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcCtrlRangeMaxAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcCtrlRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCtrlRangeMax); } -UsdAttribute MjcPhysicsTransmission::CreateMjcCtrlRangeMaxAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcCtrlRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCtrlRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcForceRangeMinAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcForceRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcForceRangeMin); } -UsdAttribute MjcPhysicsTransmission::CreateMjcForceRangeMinAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcForceRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcForceRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcForceRangeMaxAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcForceRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcForceRangeMax); } -UsdAttribute MjcPhysicsTransmission::CreateMjcForceRangeMaxAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcForceRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcForceRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcActRangeMinAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcActRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActRangeMin); } -UsdAttribute MjcPhysicsTransmission::CreateMjcActRangeMinAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcActRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcActRangeMaxAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcActRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActRangeMax); } -UsdAttribute MjcPhysicsTransmission::CreateMjcActRangeMaxAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcActRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcLengthRangeMinAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcLengthRangeMinAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcLengthRangeMin); } -UsdAttribute MjcPhysicsTransmission::CreateMjcLengthRangeMinAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcLengthRangeMinAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcLengthRangeMin, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcLengthRangeMaxAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcLengthRangeMaxAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcLengthRangeMax); } -UsdAttribute MjcPhysicsTransmission::CreateMjcLengthRangeMaxAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcLengthRangeMaxAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcLengthRangeMax, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcGearAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcGearAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGear); } -UsdAttribute MjcPhysicsTransmission::CreateMjcGearAttr( - VtValue const &defaultValue, bool writeSparsely) const { +UsdAttribute MjcPhysicsActuator::CreateMjcGearAttr(VtValue const &defaultValue, + bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcGear, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcCrankLengthAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcCrankLengthAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcCrankLength); } -UsdAttribute MjcPhysicsTransmission::CreateMjcCrankLengthAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcCrankLengthAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcCrankLength, SdfValueTypeNames->Double, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcJointInParentAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcJointInParentAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcJointInParent); } -UsdAttribute MjcPhysicsTransmission::CreateMjcJointInParentAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcJointInParentAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcJointInParent, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcActDimAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcActDimAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActDim); } -UsdAttribute MjcPhysicsTransmission::CreateMjcActDimAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcActDimAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActDim, SdfValueTypeNames->Int, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcDynTypeAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcDynTypeAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcDynType); } -UsdAttribute MjcPhysicsTransmission::CreateMjcDynTypeAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcDynTypeAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcDynType, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcGainTypeAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcGainTypeAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGainType); } -UsdAttribute MjcPhysicsTransmission::CreateMjcGainTypeAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcGainTypeAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcGainType, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcBiasTypeAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcBiasTypeAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcBiasType); } -UsdAttribute MjcPhysicsTransmission::CreateMjcBiasTypeAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcBiasTypeAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcBiasType, SdfValueTypeNames->Token, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcDynPrmAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcDynPrmAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcDynPrm); } -UsdAttribute MjcPhysicsTransmission::CreateMjcDynPrmAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcDynPrmAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcDynPrm, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcGainPrmAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcGainPrmAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcGainPrm); } -UsdAttribute MjcPhysicsTransmission::CreateMjcGainPrmAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcGainPrmAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcGainPrm, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcBiasPrmAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcBiasPrmAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcBiasPrm); } -UsdAttribute MjcPhysicsTransmission::CreateMjcBiasPrmAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcBiasPrmAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcBiasPrm, SdfValueTypeNames->DoubleArray, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdAttribute MjcPhysicsTransmission::GetMjcActEarlyAttr() const { +UsdAttribute MjcPhysicsActuator::GetMjcActEarlyAttr() const { return GetPrim().GetAttribute(MjcPhysicsTokens->mjcActEarly); } -UsdAttribute MjcPhysicsTransmission::CreateMjcActEarlyAttr( +UsdAttribute MjcPhysicsActuator::CreateMjcActEarlyAttr( VtValue const &defaultValue, bool writeSparsely) const { return UsdSchemaBase::_CreateAttr( MjcPhysicsTokens->mjcActEarly, SdfValueTypeNames->Bool, /* custom = */ false, SdfVariabilityUniform, defaultValue, writeSparsely); } -UsdRelationship MjcPhysicsTransmission::GetMjcTargetRel() const { +UsdRelationship MjcPhysicsActuator::GetMjcTargetRel() const { return GetPrim().GetRelationship(MjcPhysicsTokens->mjcTarget); } -UsdRelationship MjcPhysicsTransmission::CreateMjcTargetRel() const { +UsdRelationship MjcPhysicsActuator::CreateMjcTargetRel() const { return GetPrim().CreateRelationship(MjcPhysicsTokens->mjcTarget, /* custom = */ false); } -UsdRelationship MjcPhysicsTransmission::GetMjcRefSiteRel() const { +UsdRelationship MjcPhysicsActuator::GetMjcRefSiteRel() const { return GetPrim().GetRelationship(MjcPhysicsTokens->mjcRefSite); } -UsdRelationship MjcPhysicsTransmission::CreateMjcRefSiteRel() const { +UsdRelationship MjcPhysicsActuator::CreateMjcRefSiteRel() const { return GetPrim().CreateRelationship(MjcPhysicsTokens->mjcRefSite, /* custom = */ false); } -UsdRelationship MjcPhysicsTransmission::GetMjcSliderSiteRel() const { +UsdRelationship MjcPhysicsActuator::GetMjcSliderSiteRel() const { return GetPrim().GetRelationship(MjcPhysicsTokens->mjcSliderSite); } -UsdRelationship MjcPhysicsTransmission::CreateMjcSliderSiteRel() const { +UsdRelationship MjcPhysicsActuator::CreateMjcSliderSiteRel() const { return GetPrim().CreateRelationship(MjcPhysicsTokens->mjcSliderSite, /* custom = */ false); } @@ -371,7 +371,7 @@ static inline TfTokenVector _ConcatenateAttributeNames( } // namespace /*static*/ -const TfTokenVector &MjcPhysicsTransmission::GetSchemaAttributeNames( +const TfTokenVector &MjcPhysicsActuator::GetSchemaAttributeNames( bool includeInherited) { static TfTokenVector localNames = { MjcPhysicsTokens->mjcGroup, MjcPhysicsTokens->mjcCtrlLimited, diff --git a/src/experimental/usd/mjcPhysics/generatedSchema.usda b/src/experimental/usd/mjcPhysics/generatedSchema.usda index 517e5100..d88ae061 100644 --- a/src/experimental/usd/mjcPhysics/generatedSchema.usda +++ b/src/experimental/usd/mjcPhysics/generatedSchema.usda @@ -259,7 +259,7 @@ class "MjcMeshCollisionAPI" ( ) } -class MjcTransmission "MjcTransmission" ( +class MjcActuator "MjcActuator" ( doc = "Known as actuator in MuJoCo, this prim represents force transmission to joints, bodies, or sites." ) { diff --git a/src/experimental/usd/mjcPhysics/plugInfo.json b/src/experimental/usd/mjcPhysics/plugInfo.json index 6db3e021..6eee918a 100644 --- a/src/experimental/usd/mjcPhysics/plugInfo.json +++ b/src/experimental/usd/mjcPhysics/plugInfo.json @@ -3,6 +3,16 @@ { "Info": { "Types": { + "MjcPhysicsActuator": { + "alias": { + "UsdSchemaBase": "MjcActuator" + }, + "autoGenerated": true, + "bases": [ + "UsdTyped" + ], + "schemaKind": "concreteTyped" + }, "MjcPhysicsCollisionAPI": { "alias": { "UsdSchemaBase": "MjcCollisionAPI" @@ -62,16 +72,6 @@ "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 f60acdf4..f3e3ecc4 100644 --- a/src/experimental/usd/mjcPhysics/schema.usda +++ b/src/experimental/usd/mjcPhysics/schema.usda @@ -584,10 +584,10 @@ class "MjcMeshCollisionAPI" ) } -class MjcTransmission "MjcTransmission" +class MjcActuator "MjcActuator" ( customData = { - string className = "Transmission" + string className = "Actuator" } doc = """Known as actuator in MuJoCo, this prim represents force transmission to joints, bodies, or sites.""" diff --git a/src/experimental/usd/mjcPhysics/tokens.cpp b/src/experimental/usd/mjcPhysics/tokens.cpp index 96f0e67b..4056b5a8 100644 --- a/src/experimental/usd/mjcPhysics/tokens.cpp +++ b/src/experimental/usd/mjcPhysics/tokens.cpp @@ -146,14 +146,13 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() sparse("sparse", TfToken::Immortal), true_("true", TfToken::Immortal), user("user", TfToken::Immortal), + MjcActuator("MjcActuator", TfToken::Immortal), MjcCollisionAPI("MjcCollisionAPI", TfToken::Immortal), - MjcImageableAPI("MjcImageableAPI", 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, @@ -280,14 +279,13 @@ MjcPhysicsTokensType::MjcPhysicsTokensType() sparse, true_, user, + MjcActuator, MjcCollisionAPI, - MjcImageableAPI, MjcJointAPI, MjcKeyframe, MjcMeshCollisionAPI, MjcSceneAPI, - MjcSiteAPI, - MjcTransmission}) {} + MjcSiteAPI}) {} TfStaticData MjcPhysicsTokens; diff --git a/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc b/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc index f2dbbded..019e96cf 100644 --- a/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc +++ b/src/experimental/usd/plugins/mjcf/mujoco_to_usd.cc @@ -86,7 +86,7 @@ TF_DEFINE_PRIVATE_TOKENS(kTokens, ((materialsScope, "Materials")) ((previewSurface, "PreviewSurface")) ((keyframesScope, "Keyframes")) - ((transmissionsScope, "Transmissions")) + ((actuatorsScope, "Actuators")) ((keyframe, "Keyframe")) ((surface, "PreviewSurface")) ((world, "World")) @@ -211,7 +211,7 @@ class ModelWriter { WriteMaterials(); WriteBodies(); if (write_physics_) { - WriteTransmissions(); + WriteActuators(); } WriteKeyframes(); } @@ -1051,13 +1051,13 @@ class ModelWriter { } } - void WriteTransmission(mjsActuator *actuator, + void WriteActuator(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)) { + pxr::SdfPath actuator_path = parent_path.AppendChild(valid_name); + if (!data_->HasSpec(actuator_path)) { CreatePrimSpec(data_, parent_path, valid_name, - pxr::MjcPhysicsTokens->MjcTransmission); + pxr::MjcPhysicsTokens->MjcActuator); } pxr::SdfPath target_path; @@ -1078,18 +1078,18 @@ class ModelWriter { return; } - CreateRelationshipSpec(data_, transmission_path, + CreateRelationshipSpec(data_, actuator_path, MjcPhysicsTokens->mjcTarget, target_path, pxr::SdfVariabilityUniform); - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Int, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Int, MjcPhysicsTokens->mjcGroup, actuator->group); if (!actuator->refsite->empty()) { int refsite_id = mj_name2id(model_, mjOBJ_SITE, actuator->refsite->c_str()); pxr::SdfPath refsite_path = site_paths_[refsite_id]; - CreateRelationshipSpec(data_, transmission_path, + CreateRelationshipSpec(data_, actuator_path, MjcPhysicsTokens->mjcRefSite, refsite_path, pxr::SdfVariabilityUniform); } @@ -1098,7 +1098,7 @@ class ModelWriter { int slidersite_id = mj_name2id(model_, mjOBJ_SITE, actuator->slidersite->c_str()); pxr::SdfPath slidersite_path = site_paths_[slidersite_id]; - CreateRelationshipSpec(data_, transmission_path, + CreateRelationshipSpec(data_, actuator_path, MjcPhysicsTokens->mjcSliderSite, slidersite_path, pxr::SdfVariabilityUniform); } @@ -1115,7 +1115,7 @@ class ModelWriter { } else if (value == mjLIMITED_FALSE) { limited_token = pxr::MjcPhysicsTokens->false_; } - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Token, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Token, token, limited_token); } @@ -1132,18 +1132,18 @@ class ModelWriter { {MjcPhysicsTokens->mjcCrankLength, actuator->cranklength}, }; for (const auto &[token, value] : actuator_double_attributes) { - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Double, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Double, token, value); } - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Int, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Int, MjcPhysicsTokens->mjcActDim, actuator->actdim); - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Bool, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Bool, MjcPhysicsTokens->mjcActEarly, (bool)actuator->actearly); WriteUniformAttribute( - transmission_path, pxr::SdfValueTypeNames->DoubleArray, + actuator_path, pxr::SdfValueTypeNames->DoubleArray, MjcPhysicsTokens->mjcGear, pxr::VtDoubleArray(actuator->gear, actuator->gear + 6)); @@ -1161,10 +1161,10 @@ class ModelWriter { } else if (actuator->dyntype == mjtDyn::mjDYN_USER) { dyn_type = MjcPhysicsTokens->user; } - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Token, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Token, MjcPhysicsTokens->mjcDynType, dyn_type); WriteUniformAttribute( - transmission_path, pxr::SdfValueTypeNames->DoubleArray, + actuator_path, pxr::SdfValueTypeNames->DoubleArray, MjcPhysicsTokens->mjcDynPrm, pxr::VtDoubleArray(actuator->dynprm, actuator->dynprm + 10)); @@ -1178,10 +1178,10 @@ class ModelWriter { } else if (actuator->gaintype == mjtGain::mjGAIN_USER) { gain_type = MjcPhysicsTokens->user; } - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Token, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Token, MjcPhysicsTokens->mjcGainType, gain_type); WriteUniformAttribute( - transmission_path, pxr::SdfValueTypeNames->DoubleArray, + actuator_path, pxr::SdfValueTypeNames->DoubleArray, MjcPhysicsTokens->mjcGainPrm, pxr::VtDoubleArray(actuator->gainprm, actuator->gainprm + 10)); @@ -1195,22 +1195,22 @@ class ModelWriter { } else if (actuator->biastype == mjtBias::mjBIAS_USER) { bias_type = MjcPhysicsTokens->user; } - WriteUniformAttribute(transmission_path, pxr::SdfValueTypeNames->Token, + WriteUniformAttribute(actuator_path, pxr::SdfValueTypeNames->Token, MjcPhysicsTokens->mjcBiasType, bias_type); WriteUniformAttribute( - transmission_path, pxr::SdfValueTypeNames->DoubleArray, + actuator_path, pxr::SdfValueTypeNames->DoubleArray, MjcPhysicsTokens->mjcBiasPrm, pxr::VtDoubleArray(actuator->biasprm, actuator->biasprm + 10)); } - void WriteTransmissions() { + void WriteActuators() { pxr::SdfPath scope_path = CreatePrimSpec(data_, body_paths_[kWorldIndex], - kTokens->transmissionsScope, pxr::UsdGeomTokens->Scope); + kTokens->actuatorsScope, pxr::UsdGeomTokens->Scope); mjsActuator *actuator = mjs_asActuator(mjs_firstElement(spec_, mjOBJ_ACTUATOR)); while (actuator) { - WriteTransmission(actuator, scope_path); + WriteActuator(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 ac152a7d..1f87ae52 100644 --- a/src/experimental/usd/usd_to_mjspec.cc +++ b/src/experimental/usd/usd_to_mjspec.cc @@ -21,6 +21,7 @@ #include #include +#include #include #include #include @@ -28,7 +29,6 @@ #include #include #include -#include #include #include #include @@ -600,8 +600,8 @@ void ParseMjcPhysicsMeshCollisionAPI( } } -void ParseMjcPhysicsTransmission(mjSpec* spec, - const pxr::MjcPhysicsTransmission& tran) { +void ParseMjcPhysicsActuator(mjSpec* spec, + const pxr::MjcPhysicsActuator& tran) { pxr::UsdPrim prim = tran.GetPrim(); mjsActuator* mj_act = mjs_addActuator(spec, nullptr); mjs_setName(mj_act->element, prim.GetPath().GetAsString().c_str()); @@ -614,12 +614,12 @@ void ParseMjcPhysicsTransmission(mjSpec* spec, pxr::SdfPathVector targets; tran.GetMjcTargetRel().GetTargets(&targets); if (targets.empty()) { - mju_warning("Transmission %s has no target, skipping.", + mju_warning("Actuator %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."); + mju_warning("Actuator has more than one target, using the first."); } mjs_setString(mj_act->target, targets[0].GetAsString().c_str()); @@ -632,7 +632,7 @@ void ParseMjcPhysicsTransmission(mjSpec* spec, } 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.", + mju_warning("Actuator %s has an invalid target type, skipping.", prim.GetPath().GetAsString().c_str()); return; } @@ -1456,8 +1456,8 @@ mjSpec* mj_parseUSDStage(const pxr::UsdStageRefPtr stage) { ParseMjcPhysicsKeyframe(spec, pxr::MjcPhysicsKeyframe(prim)); it.PruneChildren(); - } else if (prim.IsA()) { - ParseMjcPhysicsTransmission(spec, pxr::MjcPhysicsTransmission(prim)); + } else if (prim.IsA()) { + ParseMjcPhysicsActuator(spec, pxr::MjcPhysicsActuator(prim)); it.PruneChildren(); } 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 a09cf111..6b9e2bfb 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 @@ -1531,7 +1531,7 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMassAPIDensity) { ExpectAttributeEqual(stage, "/test/body/box.physics:density", 1234.0f); } -TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsTransmission) { +TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsActuator) { static constexpr char xml[] = R"( @@ -1569,51 +1569,51 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsTransmission) { )"; auto stage = OpenStageWithPhysics(xml); - 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", + EXPECT_PRIM_VALID(stage, "/test/Actuators/general"); + EXPECT_PRIM_IS_A(stage, "/test/Actuators/general", + pxr::MjcPhysicsActuator); + EXPECT_REL_HAS_TARGET(stage, "/test/Actuators/general.mjc:target", "/test/body/site"); - EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:refSite", + EXPECT_REL_HAS_TARGET(stage, "/test/Actuators/general.mjc:refSite", "/test/body/ref"); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:group", 123); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:ctrlLimited", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:group", 123); + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:ctrlLimited", pxr::MjcPhysicsTokens->true_); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:ctrlRange:min", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:ctrlRange:min", 0.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:ctrlRange:max", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:ctrlRange:max", 1.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:forceLimited", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:forceLimited", pxr::MjcPhysicsTokens->true_); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:forceRange:min", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:forceRange:min", 2.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:forceRange:max", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:forceRange:max", 3.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actLimited", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:actLimited", pxr::MjcPhysicsTokens->false_); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actRange:min", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:actRange:min", 4.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actRange:max", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:actRange:max", 5.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:lengthRange:min", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:lengthRange:min", 6.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:lengthRange:max", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:lengthRange:max", 7.0); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actDim", 1); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:dynType", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:actDim", 1); + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:dynType", MjcPhysicsTokens->filter); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:gainType", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:gainType", MjcPhysicsTokens->user); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:biasType", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:biasType", MjcPhysicsTokens->user); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:actEarly", true); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:gear", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:actEarly", true); + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:gear", pxr::VtDoubleArray{{1, 2, 3, 4, 5, 6}}); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:dynPrm", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:dynPrm", pxr::VtDoubleArray{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:gainPrm", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:gainPrm", pxr::VtDoubleArray{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:biasPrm", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:biasPrm", pxr::VtDoubleArray{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}); } @@ -1638,10 +1638,10 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsJointActuator) { )"; auto stage = OpenStageWithPhysics(xml); - 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", + EXPECT_PRIM_VALID(stage, "/test/Actuators/general"); + EXPECT_PRIM_IS_A(stage, "/test/Actuators/general", + pxr::MjcPhysicsActuator); + EXPECT_REL_HAS_TARGET(stage, "/test/Actuators/general.mjc:target", "/test/axle/rod/rod_hinge"); } @@ -1663,10 +1663,10 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsBodyActuator) { )"; auto stage = OpenStageWithPhysics(xml); - 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", + EXPECT_PRIM_VALID(stage, "/test/Actuators/general"); + EXPECT_PRIM_IS_A(stage, "/test/Actuators/general", + pxr::MjcPhysicsActuator); + EXPECT_REL_HAS_TARGET(stage, "/test/Actuators/general.mjc:target", "/test/body"); } @@ -1692,14 +1692,14 @@ TEST_F(MjcfSdfFileFormatPluginTest, TestMjcPhysicsSliderCrankActuator) { )"; auto stage = OpenStageWithPhysics(xml); - 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", + EXPECT_PRIM_VALID(stage, "/test/Actuators/general"); + EXPECT_PRIM_IS_A(stage, "/test/Actuators/general", + pxr::MjcPhysicsActuator); + EXPECT_REL_HAS_TARGET(stage, "/test/Actuators/general.mjc:target", "/test/body/crank"); - EXPECT_REL_HAS_TARGET(stage, "/test/Transmissions/general.mjc:sliderSite", + EXPECT_REL_HAS_TARGET(stage, "/test/Actuators/general.mjc:sliderSite", "/test/body/slider"); - ExpectAttributeEqual(stage, "/test/Transmissions/general.mjc:crankLength", + ExpectAttributeEqual(stage, "/test/Actuators/general.mjc:crankLength", 1.23); } diff --git a/test/xml/testdata/simple_hinge.usda b/test/xml/testdata/simple_hinge.usda index 739b8265..e1cfe90b 100644 --- a/test/xml/testdata/simple_hinge.usda +++ b/test/xml/testdata/simple_hinge.usda @@ -65,8 +65,8 @@ def Xform "World" } } - def Scope "Transmissions" { - def MjcTransmission "HingeActuator" { + def Scope "Actuators" { + def MjcActuator "HingeActuator" { rel mjc:target = } }