chenlin/Mujoco_WASM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename MjcTransmission to MjcActuator in mjcPhysics schema.

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