def testProxyShape(self):
'''Test adding a Maya Reference directly undereath the proxy shape.
Add a Maya Reference using the defaults (no group or variant).
'''
kDefaultPrimName = mayaRefUtils.defaultMayaReferencePrimName()
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
self.proxyShapePathStr, self.mayaSceneStr, self.kDefaultNamespace)
# Verify that a Maya Reference prim was created.
self.assertTrue(mayaRefPrim.IsValid())
self.assertEqual(str(mayaRefPrim.GetName()), kDefaultPrimName)
self.assertTrue(mayaRefPrim.GetPrimTypeInfo().GetTypeName(),
'MayaReference')
# We should get an error (invalid prim) when adding a Maya reference under
# the proxy shape when we also add a variant set.
kDefaultVariantSetName = mayaRefUtils.defaultVariantSetName()
kDefaultVariantName = mayaRefUtils.defaultVariantName()
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
self.proxyShapePathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
variantSet=(kDefaultVariantSetName, kDefaultVariantName))
self.assertFalse(mayaRefPrim.IsValid())
def getUniqueMayaReferencePrimName(ufePathStr, startName=None):
'''Helper function to get a unique name for the Maya Reference prim.'''
newPrimName = mayaRefUtils.defaultMayaReferencePrimName(
) if not startName else startName
prim = mayaUsd.ufe.ufePathToPrim(ufePathStr)
if prim.IsValid():
return mayaUsd.ufe.uniqueChildName(prim, newPrimName)
return newPrimName
def testBadNames(self):
'''Test using bad prim and variant names.
Add a Maya Reference using a bad Maya Reference prim name and
bad Variant Set and Variant name.
'''
kDefaultPrimName = mayaRefUtils.defaultMayaReferencePrimName()
# Create another prim to test sanitizing variant set and name.
primTestSanitizeVariant = self.stage.DefinePrim(
'/Test_SanitizeVariant', 'Xform')
primPathStr = self.proxyShapePathStr + ',/Test_SanitizeVariant'
kBadPrimName = ('3' + kDefaultPrimName + '$')
kGoodPrimName = Tf.MakeValidIdentifier(kBadPrimName)
kBadVariantSetName = 'No Spaces or Special#Chars'
kGoodVariantSetName = Tf.MakeValidIdentifier(kBadVariantSetName)
kBadVariantName = '3no start digits'
kGoodVariantName = Tf.MakeValidIdentifier(kBadVariantName)
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
mayaReferencePrimName=kBadPrimName,
variantSet=(kBadVariantSetName, kBadVariantName))
# Make sure the prim has the variant set and variant with
# the sanitized names.
self.assertTrue(primTestSanitizeVariant.HasVariantSets())
vset = primTestSanitizeVariant.GetVariantSet(kGoodVariantSetName)
self.assertTrue(vset.IsValid())
self.assertEqual(vset.GetName(), kGoodVariantSetName)
self.assertTrue(vset.GetVariantNames())
self.assertTrue(vset.HasAuthoredVariant(kGoodVariantName))
self.assertEqual(vset.GetVariantSelection(), kGoodVariantName)
# Verify that the prim was created with the good name.
self.assertTrue(mayaRefPrim.IsValid())
self.assertEqual(str(mayaRefPrim.GetName()), kGoodPrimName)
self.assertEqual(mayaRefPrim,
primTestSanitizeVariant.GetChild(kGoodPrimName))
self.assertTrue(mayaRefPrim.GetPrimTypeInfo().GetTypeName(),
'MayaReference')
# Adding a Maya Reference with the same name should produce an error.
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
mayaReferencePrimName=kGoodPrimName)
self.assertFalse(mayaRefPrim.IsValid())
def testDefineInVariant(self):
'''Test the "Define in Variant" options.
Add a Maya Reference with a (default) variant set.
'''
kDefaultPrimName = mayaRefUtils.defaultMayaReferencePrimName()
kDefaultVariantSetName = mayaRefUtils.defaultVariantSetName()
kDefaultVariantName = mayaRefUtils.defaultVariantName()
# Create another prim with default variant set and name.
primTestVariant = self.stage.DefinePrim('/Test_Variant', 'Xform')
primPathStr = self.proxyShapePathStr + ',/Test_Variant'
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
variantSet=(kDefaultVariantSetName, kDefaultVariantName),
mayaAutoEdit=True)
# Make sure the prim has the variant set and variant.
self.assertTrue(primTestVariant.HasVariantSets())
vset = primTestVariant.GetVariantSet(kDefaultVariantSetName)
self.assertTrue(vset.IsValid())
self.assertEqual(vset.GetName(), kDefaultVariantSetName)
self.assertTrue(vset.GetVariantNames())
self.assertTrue(vset.HasAuthoredVariant(kDefaultVariantName))
self.assertEqual(vset.GetVariantSelection(), kDefaultVariantName)
# Verify that a Maya Reference prim was created.
self.assertTrue(mayaRefPrim.IsValid())
self.assertEqual(str(mayaRefPrim.GetName()), kDefaultPrimName)
self.assertEqual(mayaRefPrim,
primTestVariant.GetChild(kDefaultPrimName))
self.assertTrue(mayaRefPrim.GetPrimTypeInfo().GetTypeName(),
'MayaReference')
# Verify that the Maya reference prim is inside the variant,
# and that it has the expected metadata.
attr = mayaRefPrim.GetAttribute('mayaReference')
self.assertTrue(attr.IsValid())
self.assertEqual(attr.Get().resolvedPath, self.mayaSceneStr)
attr = mayaRefPrim.GetAttribute('mayaNamespace')
self.assertTrue(attr.IsValid())
self.assertEqual(attr.Get(), self.kDefaultNamespace)
attr = mayaRefPrim.GetAttribute('mayaAutoEdit')
self.assertTrue(attr.IsValid())
self.assertEqual(attr.Get(), True)
def testDefault(self):
'''Test the default options for Add Maya Reference.
Add a Maya Reference using the defaults (no group or variant).
'''
kDefaultPrimName = mayaRefUtils.defaultMayaReferencePrimName()
# Since this is a brand new prim, it should not have variant sets.
primTestDefault = self.stage.DefinePrim('/Test_Default', 'Xform')
primPathStr = self.proxyShapePathStr + ',/Test_Default'
self.assertFalse(primTestDefault.HasVariantSets())
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr, self.mayaSceneStr, self.kDefaultNamespace)
# The prim should not have any variant set.
self.assertFalse(primTestDefault.HasVariantSets())
# Verify that a Maya Reference prim was created.
self.assertTrue(mayaRefPrim.IsValid())
self.assertEqual(str(mayaRefPrim.GetName()), kDefaultPrimName)
self.assertEqual(mayaRefPrim,
primTestDefault.GetChild(kDefaultPrimName))
self.assertTrue(mayaRefPrim.GetPrimTypeInfo().GetTypeName(),
'MayaReference')
# Test an error creating the Maya reference prim by disabling permission to edit on the
# edit target layer.
editTarget = self.stage.GetEditTarget()
editLayer = editTarget.GetLayer()
editLayer.SetPermissionToEdit(False)
badMayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
mayaReferencePrimName='BadMayaReference')
self.assertFalse(badMayaRefPrim.IsValid())
editLayer.SetPermissionToEdit(True)
def testGroup(self):
'''Test the "Group" options.
Add a Maya Reference using a group.
'''
kDefaultPrimName = mayaRefUtils.defaultMayaReferencePrimName()
kDefaultVariantSetName = mayaRefUtils.defaultVariantSetName()
kDefaultVariantName = mayaRefUtils.defaultVariantName()
# Create another prim to test adding a group prim (with variant).
primTestGroup = self.stage.DefinePrim('/Test_Group', 'Xform')
primPathStr = self.proxyShapePathStr + ',/Test_Group'
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
groupPrim=('Xform', Kind.Tokens.group),
variantSet=(kDefaultVariantSetName, kDefaultVariantName))
# Make sure a group prim was created.
# Since we did not provide a group name, one will have been auto-generated for us.
# "namespace" + "RN" + "group"
primGroup = primTestGroup.GetChild(self.kDefaultNamespace + 'RNgroup')
self.assertTrue(primGroup.IsValid())
self.assertTrue(primGroup.GetPrimTypeInfo().GetTypeName(), 'Xform')
model = Usd.ModelAPI(primGroup)
self.assertEqual(model.GetKind(), Kind.Tokens.group)
# Make sure the group prim has the variant set and variant.
self.assertTrue(primGroup.HasVariantSets())
vset = primGroup.GetVariantSet(kDefaultVariantSetName)
self.assertTrue(vset.IsValid())
self.assertEqual(vset.GetName(), kDefaultVariantSetName)
self.assertTrue(vset.GetVariantNames())
self.assertTrue(vset.HasAuthoredVariant(kDefaultVariantName))
self.assertEqual(vset.GetVariantSelection(), kDefaultVariantName)
# Verify that a Maya Reference prim was created under the new group prim.
self.assertTrue(mayaRefPrim.IsValid())
self.assertEqual(str(mayaRefPrim.GetName()), kDefaultPrimName)
self.assertEqual(mayaRefPrim, primGroup.GetChild(kDefaultPrimName))
self.assertTrue(mayaRefPrim.GetPrimTypeInfo().GetTypeName(),
'MayaReference')
# Add another Maya reference with group, but name the group this time and
# use a 'Scope' prim instead.
kGroupName = 'NewGroup'
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
groupPrim=(kGroupName, 'Scope', Kind.Tokens.group))
# Make sure a group prim was created and what we named it.
prim2ndGroup = primTestGroup.GetChild(kGroupName)
self.assertTrue(prim2ndGroup.IsValid())
self.assertTrue(prim2ndGroup.GetPrimTypeInfo().GetTypeName(), 'Scope')
model = Usd.ModelAPI(prim2ndGroup)
self.assertEqual(model.GetKind(), Kind.Tokens.group)
# Verify that a Maya Reference prim was created under the new group prim.
self.assertTrue(mayaRefPrim.IsValid())
self.assertEqual(str(mayaRefPrim.GetName()), kDefaultPrimName)
self.assertEqual(mayaRefPrim, prim2ndGroup.GetChild(kDefaultPrimName))
self.assertTrue(mayaRefPrim.GetPrimTypeInfo().GetTypeName(),
'MayaReference')
# Adding a group with the same name should produce an error.
mayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
groupPrim=(kGroupName, 'Scope', Kind.Tokens.group))
self.assertFalse(mayaRefPrim.IsValid())
# Test an error creating the group prim by disabling permission to edit on the edit target layer.
editTarget = self.stage.GetEditTarget()
editLayer = editTarget.GetLayer()
editLayer.SetPermissionToEdit(False)
badMayaRefPrim = mayaUsdAddMayaReference.createMayaReferencePrim(
primPathStr,
self.mayaSceneStr,
self.kDefaultNamespace,
groupPrim=('NoGroup', 'Xform', Kind.Tokens.group))
self.assertFalse(badMayaRefPrim.IsValid())
invalidGroupPrim = primTestGroup.GetChild('NoGroup')
self.assertFalse(invalidGroupPrim.IsValid())
editLayer.SetPermissionToEdit(True)
def createMayaReferencePrim(
ufePathStr,
mayaReferencePath,
mayaNamespace,
mayaReferencePrimName=mayaRefUtils.defaultMayaReferencePrimName(),
groupPrim=None,
variantSet=None,
mayaAutoEdit=kDefaultEditAsMayaData):
'''Create a Maya reference prim and optional group prim parented to the argument path.
Optionally create a variant set and name and placed the edits inside that variant.
Naming of Maya Reference prim is supported, otherwise default name is used.
The group prim is optional.
The variant set and name are optional
Parameters:
-----------
ufePathStr : str : Ufe PathString of parent prim to add Maya Reference
mayaReferencePath : str : File path of Maya Reference (for attribute)
mayaNamespace : str : Namespace (for attribute)
mayaReferencePrimName : str [optional] : Name for the Maya Reference prim
groupPrim : tuple(str,str,str) [optional] : The Group prim Name, Type & Kind to create
Note: the name is optional and will be auto-computed
if empty or not provided.
Note: Type and Kind are both mandatory, but Kind is
allowed to be empty string.
variantSet : tuple(str,str) [optional] : The Variant Set Name and Variant Name to create
Return:
-------
The Usd prim of the newly created Maya Reference or an invalid prim if there is an error.
'''
# Make sure the prim name is valid and doesn't already exist.
parentPrim = mayaUsd.ufe.ufePathToPrim(ufePathStr)
# There are special conditions when we are given the ProxyShape gateway node.
ufePath = ufe.PathString.path(ufePathStr)
isGateway = (ufePath.nbSegments() == 1)
# Were we given a Group prim to create?
groupPrimName = None
groupPrimType = None
groupPrimKind = None
if groupPrim:
if (len(groupPrim) == 2):
groupPrimType, groupPrimKind = groupPrim
elif (len(groupPrim) == 3):
groupPrimName, groupPrimType, groupPrimKind = groupPrim
# Make sure the input Group prim name doesn't exist already
# and validate the input name.
# Note: it is allowed to be input as empty in which case a default is used.
if groupPrimName:
checkGroupPrimName = mayaUsd.ufe.uniqueChildName(
parentPrim, groupPrimName)
if checkGroupPrimName != groupPrimName:
errorMsgFormat = getMayaUsdLibString(
'kErrorGroupPrimExists')
errorMsg = cmds.format(errorMsgFormat,
stringArg=(groupPrimName,
ufePathStr))
om.MGlobal.displayError(errorMsg)
return Usd.Prim()
groupPrimName = Tf.MakeValidIdentifier(checkGroupPrimName)
# If the group prim was either not provided or empty we use a default name.
if not groupPrimName:
groupPrimName = getDefaultGroupPrimName(parentPrim, mayaNamespace)
# When the input is a gateway we cannot have in variant unless group is also given.
if isGateway and variantSet and not groupPrimName:
errorMsg = getMayaUsdLibString('kErrorCannotAddToProxyShape')
om.MGlobal.displayError(errorMsg)
return Usd.Prim()
# Make sure the input Maya Reference prim name doesn't exist already
# and validate the input name.
# Note: if we are given a group prim to create, then we know that the
# Maya Reference prim name will be unique since it will be the
# only child (of the newly created group prim).
checkName = mayaUsd.ufe.uniqueChildName(
parentPrim,
mayaReferencePrimName) if groupPrim is None else mayaReferencePrimName
if checkName != mayaReferencePrimName:
errorMsgFormat = getMayaUsdLibString('kErrorMayaRefPrimExists')
errorMsg = cmds.format(errorMsgFormat,
stringArg=(mayaReferencePrimName, ufePathStr))
om.MGlobal.displayError(errorMsg)
return Usd.Prim()
validatedPrimName = Tf.MakeValidIdentifier(checkName)
# Extract the USD path segment from the UFE path and append the Maya
# reference prim to it.
parentPath = str(ufePath.segments[1]) if ufePath.nbSegments() > 1 else ''
stage = mayaUsd.ufe.getStage(ufePathStr)
# Optionally insert a Group prim as a parent of the Maya reference prim.
groupPrim = None
if groupPrimName:
groupPath = Sdf.AssetPath(parentPath + '/' + groupPrimName)
try:
groupPrim = stage.DefinePrim(groupPath.path, groupPrimType)
except (Tf.ErrorException):
groupPrim = Usd.Prim()
if not groupPrim.IsValid():
errorMsgFormat = getMayaUsdLibString('kErrorCreatingGroupPrim')
errorMsg = cmds.format(errorMsgFormat, stringArg=(ufePathStr))
om.MGlobal.displayError(errorMsg)
return Usd.Prim()
if groupPrimKind:
model = Usd.ModelAPI(groupPrim)
model.SetKind(groupPrimKind)
if groupPrim:
primPath = Sdf.AssetPath(groupPrim.GetPath().pathString + '/' +
validatedPrimName)
else:
primPath = Sdf.AssetPath(parentPath + '/' + validatedPrimName)
# Were we given a Variant Set to create?
variantSetName = None
variantName = None
if variantSet and (len(variantSet) == 2):
variantSetName, variantName = variantSet
if variantSetName and variantName:
validatedVariantSetName = Tf.MakeValidIdentifier(variantSetName)
validatedVariantName = Tf.MakeValidIdentifier(variantName)
# If we created a group prim add the variant set there, otherwise add it
# to the prim that corresponds to the input ufe path.
variantPrim = groupPrim if groupPrim else mayaUsd.ufe.ufePathToPrim(
ufePathStr)
vset = variantPrim.GetVariantSet(validatedVariantSetName)
vset.AddVariant(validatedVariantName)
vset.SetVariantSelection(validatedVariantName)
with vset.GetVariantEditContext():
# Now all of our subsequent edits will go "inside" the
# 'variantName' variant of 'variantSetName'.
prim = createPrimAndAttributes(stage, primPath, mayaReferencePath,
mayaNamespace, mayaAutoEdit)
else:
prim = createPrimAndAttributes(stage, primPath, mayaReferencePath,
mayaNamespace, mayaAutoEdit)
if prim is None or not prim.IsValid():
errorMsgFormat = getMayaUsdLibString('kErrorCreatingMayaRefPrim')
errorMsg = cmds.format(errorMsgFormat, stringArg=(ufePathStr))
om.MGlobal.displayError(errorMsg)
return Usd.Prim()
return prim