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
// 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 <mujoco/experimental/usd/mjcPhysics/api.h>
#include <mujoco/experimental/usd/mjcPhysics/tokens.h>
@@ -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.
include/mujoco/experimental/usd/mjcPhysics/tokens.h
+56 -60
View File
@@ -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<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)
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}
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
// 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/types.h>
@@ -23,338 +23,338 @@ PXR_NAMESPACE_OPEN_SCOPE
// Register the schema with the TfType system.
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
// enables one to call
// TfType::Find<UsdSchemaBase>().FindDerivedByName("MjcTransmission")
// to find TfType<MjcPhysicsTransmission>, which is how IsA queries are
// TfType::Find<UsdSchemaBase>().FindDerivedByName("MjcActuator")
// to find TfType<MjcPhysicsActuator>, which is how IsA queries are
// answered.
TfType::AddAlias<UsdSchemaBase, MjcPhysicsTransmission>("MjcTransmission");
TfType::AddAlias<UsdSchemaBase, MjcPhysicsActuator>("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<MjcPhysicsTransmission>();
const TfType &MjcPhysicsActuator::_GetStaticTfType() {
static TfType tfType = TfType::Find<MjcPhysicsActuator>();
return tfType;
}
/* static */
bool MjcPhysicsTransmission::_IsTypedSchema() {
bool MjcPhysicsActuator::_IsTypedSchema() {
static bool isTyped = _GetStaticTfType().IsA<UsdTyped>();
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,
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."
)
{
src/experimental/usd/mjcPhysics/plugInfo.json
+10 -10
View File
@@ -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"
}
}
},
src/experimental/usd/mjcPhysics/schema.usda
+2 -2
View File
@@ -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."""
src/experimental/usd/mjcPhysics/tokens.cpp
+3 -5
View File
@@ -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<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"))
((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));
}
}
src/experimental/usd/usd_to_mjspec.cc
+8 -8
View File
@@ -21,6 +21,7 @@
#include <utility>
#include <vector>
#include <mujoco/experimental/usd/mjcPhysics/actuator.h>
#include <mujoco/experimental/usd/mjcPhysics/collisionAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/jointAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/keyframe.h>
@@ -28,7 +29,6 @@
#include <mujoco/experimental/usd/mjcPhysics/sceneAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/siteAPI.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/utils.h>
#include <mujoco/mujoco.h>
@@ -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<pxr::MjcPhysicsSiteAPI>()) {
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<pxr::MjcPhysicsTransmission>()) {
ParseMjcPhysicsTransmission(spec, pxr::MjcPhysicsTransmission(prim));
} else if (prim.IsA<pxr::MjcPhysicsActuator>()) {
ParseMjcPhysicsActuator(spec, pxr::MjcPhysicsActuator(prim));
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 <gtest/gtest.h>
#include <mujoco/experimental/usd/mjcPhysics/actuator.h>
#include <mujoco/experimental/usd/mjcPhysics/collisionAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/jointAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/meshCollisionAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/sceneAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/siteAPI.h>
#include <mujoco/experimental/usd/mjcPhysics/tokens.h>
#include <mujoco/experimental/usd/mjcPhysics/transmission.h>
#include "test/experimental/usd/test_utils.h"
#include "test/fixture.h"
#include <pxr/base/gf/quatf.h>
@@ -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"(
<mujoco model="test">
<worldbody>
@@ -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);
}
test/xml/testdata/simple_hinge.usda
Vendored
+2 -2
View File
@@ -65,8 +65,8 @@ def Xform "World"
}
}
def Scope "Transmissions" {
def MjcTransmission "HingeActuator" {
def Scope "Actuators" {
def MjcActuator "HingeActuator" {
rel mjc:target = </World/Axle/Rod/HingeJoint>
}
}