def testAlreadyChild(self):
'''Parenting an object to its current parent is a no-op.'''
with OpenFileCtx("simpleHierarchy.ma"):
shapeSegment = mayaUtils.createUfePathSegment(
"|world|mayaUsdProxy1|mayaUsdProxyShape1")
spherePath = ufe.Path(
[shapeSegment,
usdUtils.createUfePathSegment("/pCylinder1/pCube1/pSphere1")])
sphereItem = ufe.Hierarchy.createItem(spherePath)
cylinderShapePath = ufe.Path(
[shapeSegment,
usdUtils.createUfePathSegment("/pCylinder1/pCylinderShape1")])
cylinderShapeItem = ufe.Hierarchy.createItem(cylinderShapePath)
parentPath = ufe.Path(
[shapeSegment, usdUtils.createUfePathSegment("/pCylinder1")])
parentItem = ufe.Hierarchy.createItem(parentPath)
parent = ufe.Hierarchy.hierarchy(parentItem)
childrenPre = parent.children()
# get the USD stage
stage = mayaUsd.ufe.getStage(str(shapeSegment))
# check GetLayerStack behavior
self.assertEqual(stage.GetEditTarget().GetLayer(), stage.GetRootLayer())
# The sphere is not a child of the cylinder
self.assertNotIn("pSphere1", childrenNames(childrenPre))
# The cylinder shape is a child of the cylinder
self.assertIn("pCylinderShape1", childrenNames(childrenPre))
# Parent the sphere and the cylinder shape to the cylinder. This
# is a no-op for the cylinder shape, as it's already a child of the
# cylinder, and the sphere is parented to the cylinder.
cmds.parent(ufe.PathString.string(spherePath),
ufe.PathString.string(cylinderShapePath),
ufe.PathString.string(parentPath))
children = parent.children()
self.assertEqual(len(childrenPre)+1, len(children))
self.assertIn("pSphere1", childrenNames(children))
self.assertIn("pCylinderShape1", childrenNames(children))
# Undo / redo
cmds.undo()
children = parent.children()
self.assertEqual(len(childrenPre), len(children))
self.assertNotIn("pSphere1", childrenNames(children))
self.assertIn("pCylinderShape1", childrenNames(children))
cmds.redo()
children = parent.children()
self.assertEqual(len(childrenPre)+1, len(children))
self.assertIn("pSphere1", childrenNames(children))
self.assertIn("pCylinderShape1", childrenNames(children))
def testMultiSelectMoveUSD(self):
'''Move multiple USD objects, read through Transform3d interface.'''
# Select multiple balls to move them.
proxyShapePathSegment = mayaUtils.createUfePathSegment(
"|world|transform1|proxyShape1")
balls = ['Ball_33', 'Ball_34']
ballPaths = [
ufe.Path([
proxyShapePathSegment,
usdUtils.createUfePathSegment('/Room_set/Props/' + ball)
]) for ball in balls
]
ballItems = [
ufe.Hierarchy.createItem(ballPath) for ballPath in ballPaths
]
for ballItem in ballItems:
ufe.GlobalSelection.get().append(ballItem)
# We compare the UFE translation with the USD run-time translation. To
# obtain the full translation of USD scene items, we need to add the USD
# translation to the Maya proxy shape translation.
proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(
0).node()
proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)
def usdSceneItemTranslation(item):
prim = usdUtils.getPrimFromSceneItem(item)
if not prim.HasAttribute('xformOp:translate'):
return proxyShapeXformFn.translation(om.MSpace.kTransform)
else:
return addVec(
proxyShapeXformFn.translation(om.MSpace.kTransform),
prim.GetAttribute('xformOp:translate').Get())
def ufeSceneItemTranslation(item):
return transform3dTranslation(ufe.Transform3d.transform3d(item))
# Set up the callables that will retrieve the translation.
self.runTimeTranslation = usdSceneItemTranslation
self.ufeTranslation = ufeSceneItemTranslation
# Give the tail item in the selection an initial translation that
# is different, to catch bugs where the relative translation
# incorrectly squashes any existing translation.
backItem = ballItems[-1]
backT3d = ufe.Transform3d.transform3d(backItem)
initialTranslation = [-10, -20, -30]
backT3d.translate(*initialTranslation)
assertVectorAlmostEqual(self, ufeSceneItemTranslation(backItem),
usdSceneItemTranslation(backItem))
# Save the initial positions to the memento list.
expected = [
usdSceneItemTranslation(ballItem) for ballItem in ballItems
]
self.runMultiSelectTestMove(ballItems, expected)
def testAttributes(self):
'''Engine method to run attributes test.'''
# Get a UFE scene item for one of the balls in the scene.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
# Then create the attributes interface for that item.
ball35Attrs = ufe.Attributes.attributes(ball35Item)
self.assertIsNotNone(ball35Attrs)
# Test that we get the same scene item back.
self.assertEqual(ball35Item, ball35Attrs.sceneItem())
# Verify that ball35 contains the visibility attribute.
self.assertTrue(ball35Attrs.hasAttribute(UsdGeom.Tokens.visibility))
# Verify the attribute type of 'visibility' which we know is a enum token.
self.assertEqual(ball35Attrs.attributeType(UsdGeom.Tokens.visibility),
ufe.Attribute.kEnumString)
# Get all the attribute names for this item.
ball35AttrNames = ball35Attrs.attributeNames
# Visibility should be in this list.
self.assertIn(UsdGeom.Tokens.visibility, ball35AttrNames)
def setUp(self):
''' Called initially to set up the maya test environment '''
# Load plugins
self.assertTrue(self.pluginsLoaded)
# These tests requires no additional setup.
if self._testMethodName in [
'testAddNewPrim', 'testAddNewPrimWithDelete'
]:
return
# Open top_layer.ma scene in test-samples
mayaUtils.openTopLayerScene()
# Clear selection to start off.
ufe.GlobalSelection.get().clear()
# Select Ball_35.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
self.ball35Item = ufe.Hierarchy.createItem(ball35Path)
self.ball35Prim = usdUtils.getPrimFromSceneItem(self.ball35Item)
ufe.GlobalSelection.get().append(self.ball35Item)
# Create a ContextOps interface for it.
self.contextOps = ufe.ContextOps.contextOps(self.ball35Item)
def setUp(self):
''' Called initially to set up the maya test environment '''
# Load plugins
self.assertTrue(self.pluginsLoaded)
# Open top_layer.ma scene in test-samples
mayaUtils.openTopLayerScene()
# Create a proxy shape with empty stage to start with.
import mayaUsd_createStageWithNewLayer
mayaUsd_createStageWithNewLayer.createStageWithNewLayer()
# Clear selection to start off.
ufe.GlobalSelection.get().clear()
# Select Ball_35.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
self.ball35Item = ufe.Hierarchy.createItem(ball35Path)
ufe.GlobalSelection.get().append(self.ball35Item)
# Create a ContextOps interface for it.
self.contextOps = ufe.ContextOps.contextOps(self.ball35Item)
def testMoveUSD(self):
'''Move USD object, read through the Transform3d interface.'''
# Select Ball_35 to move it.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
ufe.GlobalSelection.get().append(ball35Item)
# Create a Transform3d interface for it.
transform3d = ufe.Transform3d.transform3d(ball35Item)
# We compare the UFE translation with the USD run-time translation. To
# obtain the full translation of Ball_35, we need to add the USD
# translation to the Maya proxy shape translation.
proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(0).node()
proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)
def ball35Translation():
ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
return addVec(
proxyShapeXformFn.translation(om.MSpace.kTransform),
ball35Prim.GetAttribute('xformOp:translate').Get())
# Set up the callables that will retrieve the translation.
self.runTimeTranslation = ball35Translation
self.ufeTranslation = partial(transform3dTranslation, transform3d)
# Save the initial position to the memento list.
expected = ball35Translation()
self.runTestMove(expected)
def testScaleUSD(self):
'''Scale USD object, read through the Transform3d interface.'''
# Select Ball_35 to scale it.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
ufe.GlobalSelection.get().append(ball35Item)
# Create a Transform3d interface for it.
transform3d = ufe.Transform3d.transform3d(ball35Item)
# We compare the UFE scale with the USD run-time scale. To
# obtain the full scale of Ball_35, we need to add the USD
# scale to the Maya proxy shape scale.
proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(0).node()
proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)
def ball35Scale():
ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
if not ball35Prim.HasAttribute('xformOp:scale'):
return proxyShapeXformFn.scale()
else:
return combineScales(proxyShapeXformFn.scale(), ball35Prim.GetAttribute('xformOp:scale').Get())
# Set up the callables that will retrieve the scale.
self.runTimeScale = ball35Scale
self.ufeScale = partial(transform3dScale, transform3d)
# Save the initial position to the memento list.
expected = ball35Scale()
self.runTestScale(expected)
def testRenameRestrictionSameLayerDef(self):
'''Restrict renaming USD node. Cannot rename a prim defined on another layer.'''
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment(
'|world|transform1|proxyShape1')
usdPathSegment = usdUtils.createUfePathSegment(
'/Room_set/Props/Ball_35')
ball35Path = ufe.Path([mayaPathSegment, usdPathSegment])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
ufe.GlobalSelection.get().append(ball35Item)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# check GetLayerStack behavior
self.assertEqual(stage.GetLayerStack()[0], stage.GetSessionLayer())
self.assertEqual(stage.GetEditTarget().GetLayer(),
stage.GetRootLayer())
# expect the exception happens
with self.assertRaises(RuntimeError):
newName = 'Ball_35_Renamed'
cmds.rename(newName)
def testRenameRestrictionHasSpecs(self):
'''Restrict renaming USD node. Cannot rename a node that doesn't contribute to the final composed prim'''
# open appleBite.ma scene in test-samples
mayaUtils.openAppleBiteScene()
# clear selection to start off
cmds.select(clear=True)
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment(
'|world|Asset_flattened_instancing_and_class_removed_usd|Asset_flattened_instancing_and_class_removed_usdShape'
)
usdPathSegment = usdUtils.createUfePathSegment('/apple/payload/geo')
geoPath = ufe.Path([mayaPathSegment, usdPathSegment])
geoItem = ufe.Hierarchy.createItem(geoPath)
ufe.GlobalSelection.get().append(geoItem)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# rename "/apple/payload/geo" to "/apple/payload/geo_renamed"
# expect the exception happens
with self.assertRaises(RuntimeError):
cmds.rename("geo_renamed")
def testRenameRestrictionOtherLayerOpinions(self):
'''Restrict renaming USD node. Cannot rename a prim with definitions or opinions on other layers.'''
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment(
'|world|transform1|proxyShape1')
usdPathSegment = usdUtils.createUfePathSegment(
'/Room_set/Props/Ball_35')
ball35Path = ufe.Path([mayaPathSegment, usdPathSegment])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
ufe.GlobalSelection.get().append(ball35Item)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# set the edit target to Assembly_room_set.usda
stage.SetEditTarget(stage.GetLayerStack()[2])
self.assertEqual(stage.GetEditTarget().GetLayer().GetDisplayName(),
"Assembly_room_set.usda")
# expect the exception happens
with self.assertRaises(RuntimeError):
newName = 'Ball_35_Renamed'
cmds.rename(newName)
def testRenameUniqueName(self):
# open tree.ma scene in test-samples
mayaUtils.openTreeScene()
# clear selection to start off
cmds.select(clear=True)
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment('|world|Tree_usd|Tree_usdShape')
usdPathSegment = usdUtils.createUfePathSegment('/TreeBase/trunk')
trunkPath = ufe.Path([mayaPathSegment, usdPathSegment])
trunkItem = ufe.Hierarchy.createItem(trunkPath)
ufe.GlobalSelection.get().append(trunkItem)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# by default edit target is set to the Rootlayer.
self.assertEqual(stage.GetEditTarget().GetLayer(), stage.GetRootLayer())
# rename `/TreeBase/trunk` to `/TreeBase/leavesXform`
cmds.rename("leavesXform")
# get the prim
item = ufe.GlobalSelection.get().front()
usdPrim = stage.GetPrimAtPath(str(item.path().segments[1]))
self.assertTrue(usdPrim)
# the new prim name is expected to be "leavesXform1"
assert ([x for x in stage.Traverse()] == [stage.GetPrimAtPath("/TreeBase"),
stage.GetPrimAtPath("/TreeBase/leavesXform"),
stage.GetPrimAtPath("/TreeBase/leavesXform/leaves"),
stage.GetPrimAtPath("/TreeBase/leavesXform1"),])
def _testMultiSelectRotateUSD(self):
'''Rotate multiple USD objects, read through Transform3d interface.'''
# Select multiple balls to rotate them.
proxyShapePathSegment = mayaUtils.createUfePathSegment(
"|world|transform1|proxyShape1")
balls = ['Ball_33', 'Ball_34']
ballPaths = [
ufe.Path([proxyShapePathSegment,
usdUtils.createUfePathSegment('/Room_set/Props/'+ball)])
for ball in balls]
ballItems = [ufe.Hierarchy.createItem(ballPath)
for ballPath in ballPaths]
for ballItem in ballItems:
ufe.GlobalSelection.get().append(ballItem)
# We compare the UFE rotation with the USD run-time rotation. To
# obtain the full rotation of USD scene items, we need to add the USD
# rotation to the Maya proxy shape rotation.
proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(0).node()
proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)
def usdSceneItemRotation(item):
prim = usdUtils.getPrimFromSceneItem(item)
if not prim.HasAttribute('xformOp:rotateXYZ'):
return proxyShapeXformFn.rotation(om.MSpace.kTransform)
else:
x,y,z = prim.GetAttribute('xformOp:rotateXYZ').Get()
return proxyShapeXformFn.rotation(om.MSpace.kTransform) + om.MEulerRotation(radians(x), radians(y), radians(z))
def ufeSceneItemRotation(item):
return transform3dRotation(ufe.Transform3d.transform3d(item))
# Set up the callables that will retrieve the rotation.
self.runTimeRotation = usdSceneItemRotation
self.ufeRotation = ufeSceneItemRotation
# Give the tail item in the selection an initial rotation that
# is different, to catch bugs where the relative rotation
# incorrectly squashes any existing rotation.
backItem = ballItems[-1]
backT3d = ufe.Transform3d.transform3d(backItem)
initialRot = [-10, -20, -30]
backT3d.rotate(*initialRot)
assertVectorAlmostEqual(self, [radians(a) for a in initialRot],
usdSceneItemRotation(backItem))
# Save the initial positions to the memento list.
expected = [usdSceneItemRotation(ballItem) for ballItem in ballItems]
# MAYA-96058: unfortunately, rotate command currently requires a rotate
# manipulator to be created to update the UFE object.
manipCtx = cmds.manipRotateContext()
cmds.setToolTo(manipCtx)
#Temporarily disabling undo redo until we fix it for PR 94
self.runMultiSelectTestRotate(ballItems, expected)
def testAnimatedBoundingBox(self):
'''Test the Object3d bounding box interface for animated geometry.'''
# Load up a scene with a sphere that has an animated radius, with
# time connected to the proxy shape.
filePath = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"test-samples", "sphereAnimatedRadius",
"sphereAnimatedRadiusProxyShape.ma")
cmds.file(filePath, force=True, open=True)
# The extents of the sphere are copied from the .usda file.
expected = [[(-1.0000002, -1, -1.0000005), (1, 1, 1.0000001)],
[(-1.3086424, -1.308642, -1.3086426),
(1.308642, 1.308642, 1.3086421)],
[(-2.135803, -2.1358025, -2.1358035),
(2.1358025, 2.1358025, 2.1358027)],
[(-3.333334, -3.3333333, -3.333335),
(3.3333333, 3.3333333, 3.3333337)],
[(-4.7530875, -4.7530866, -4.753089),
(4.7530866, 4.7530866, 4.753087)],
[(-6.246915, -6.2469134, -6.2469163),
(6.2469134, 6.2469134, 6.2469144)],
[(-7.6666684, -7.6666665, -7.6666703),
(7.6666665, 7.6666665, 7.6666675)],
[(-8.8642, -8.864198, -8.864202),
(8.864198, 8.864198, 8.864199)],
[(-9.6913595, -9.691358, -9.691362),
(9.691358, 9.691358, 9.691359)],
[(-10.000002, -10, -10.000005), (10, 10, 10.000001)]]
# Create an Object3d interface for USD sphere.
mayaPathSegment = mayaUtils.createUfePathSegment(
'|world|transform1|proxyShape1')
usdPathSegment = usdUtils.createUfePathSegment('/pSphere1')
spherePath = ufe.Path([mayaPathSegment, usdPathSegment])
sphereItem = ufe.Hierarchy.createItem(spherePath)
object3d = ufe.Object3d.object3d(sphereItem)
# Loop over frames 1 to 10, and compare the values returned to the
# expected values.
for frame in xrange(1, 11):
cmds.currentTime(frame)
ufeBBox = object3d.boundingBox()
# Compare it to known extents.
assertVectorAlmostEqual(self,
ufeBBox.min.vector,
expected[frame - 1][0],
places=6)
assertVectorAlmostEqual(self,
ufeBBox.max.vector,
expected[frame - 1][1],
places=6)
def testRename(self):
'''Rename USD node.'''
# Select a USD object.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
ball35Hierarchy = ufe.Hierarchy.hierarchy(ball35Item)
propsItem = ball35Hierarchy.parent()
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildrenPre = propsHierarchy.children()
ufe.GlobalSelection.get().append(ball35Item)
newName = 'Ball_35_Renamed'
cmds.rename(newName)
# The renamed item is in the selection.
snIter = iter(ufe.GlobalSelection.get())
ball35RenItem = next(snIter)
ball35RenName = str(ball35RenItem.path().back())
self.assertEqual(ball35RenName, newName)
# MAYA-92350: should not need to re-bind hierarchy interface objects
# with their item.
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildren = propsHierarchy.children()
self.assertEqual(len(propsChildren), len(propsChildrenPre))
self.assertIn(ball35RenItem, propsChildren)
cmds.undo()
def childrenNames(children):
return [str(child.path().back()) for child in children]
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildren = propsHierarchy.children()
propsChildrenNames = childrenNames(propsChildren)
self.assertNotIn(ball35RenName, propsChildrenNames)
self.assertIn('Ball_35', propsChildrenNames)
self.assertEqual(len(propsChildren), len(propsChildrenPre))
cmds.redo()
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildren = propsHierarchy.children()
propsChildrenNames = childrenNames(propsChildren)
self.assertIn(ball35RenName, propsChildrenNames)
self.assertNotIn('Ball_35', propsChildrenNames)
self.assertEqual(len(propsChildren), len(propsChildrenPre))
def testRename(self):
# open tree.ma scene in test-samples
mayaUtils.openTreeScene()
# clear selection to start off
cmds.select(clear=True)
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment('|world|Tree_usd|Tree_usdShape')
usdPathSegment = usdUtils.createUfePathSegment('/TreeBase')
treebasePath = ufe.Path([mayaPathSegment, usdPathSegment])
treebaseItem = ufe.Hierarchy.createItem(treebasePath)
ufe.GlobalSelection.get().append(treebaseItem)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# by default edit target is set to the Rootlayer.
self.assertEqual(stage.GetEditTarget().GetLayer(), stage.GetRootLayer())
self.assertTrue(stage.GetRootLayer().GetPrimAtPath("/TreeBase"))
# get default prim
defaultPrim = stage.GetDefaultPrim()
self.assertEqual(defaultPrim.GetName(), 'TreeBase')
# TreeBase has two childern: leavesXform, trunk
assert len(defaultPrim.GetChildren()) == 2
# get prim spec for defaultPrim
primspec = stage.GetEditTarget().GetPrimSpecForScenePath(defaultPrim.GetPath());
# set primspec name
primspec.name = "TreeBase_potato"
# get the renamed prim
renamedPrim = stage.GetPrimAtPath('/TreeBase_potato')
# One must use the SdfLayer API for setting the defaultPrim when you rename the prim it identifies.
stage.SetDefaultPrim(renamedPrim);
# get defaultPrim again
defaultPrim = stage.GetDefaultPrim()
self.assertEqual(defaultPrim.GetName(), 'TreeBase_potato')
# make sure we have a valid prims after the primspec rename
assert stage.GetPrimAtPath('/TreeBase_potato')
assert stage.GetPrimAtPath('/TreeBase_potato/leavesXform')
# prim should be called TreeBase_potato
potatoPrim = stage.GetPrimAtPath('/TreeBase_potato')
self.assertEqual(potatoPrim.GetName(), 'TreeBase_potato')
# prim should be called leaves
leavesPrimSpec = stage.GetObjectAtPath('/TreeBase_potato/leavesXform/leaves')
self.assertEqual(leavesPrimSpec.GetName(), 'leaves')
def testBoundingBox(self):
'''Test the Object3d bounding box interface.'''
# Create a simple USD scene. Default sphere radius is 1, so extents
# are from (-1, -1, -1) to (1, 1, 1).
usdFilePath = cmds.internalVar(utd=1) + '/testObject3d.usda'
stage = Usd.Stage.CreateNew(usdFilePath)
xform = stage.DefinePrim('/parent', 'Xform')
sphere = stage.DefinePrim('/parent/sphere', 'Sphere')
extentAttr = sphere.GetAttribute('extent')
extent = extentAttr.Get()
assertVectorAlmostEqual(self, extent[0], [-1] * 3)
assertVectorAlmostEqual(self, extent[1], [1] * 3)
# Move the sphere. Its UFE bounding box should not be affected by
# transformation hierarchy.
UsdGeom.XformCommonAPI(xform).SetTranslate((7, 8, 9))
# Save out the file, and bring it back into Maya under a proxy shape.
stage.GetRootLayer().Save()
proxyShape = cmds.createNode('mayaUsdProxyShape')
cmds.setAttr('mayaUsdProxyShape1.filePath', usdFilePath, type='string')
# MAYA-101766: loading a stage is done by the proxy shape compute.
# Because we're a script, no redraw is done, so need to pull explicitly
# on the outStageData (and simply discard the returned data), to get
# the proxy shape compute to run, and thus the stage to load. This
# should be improved. Without a loaded stage, UFE item creation
# fails. PPT, 31-10-2019.
outStageData = nameToPlug('mayaUsdProxyShape1.outStageData')
outStageData.asMDataHandle()
proxyShapeMayaPath = cmds.ls(proxyShape, long=True)[0]
proxyShapePathSegment = mayaUtils.createUfePathSegment(
proxyShapeMayaPath)
# Create a UFE scene item from the sphere prim.
spherePathSegment = usdUtils.createUfePathSegment('/parent/sphere')
spherePath = ufe.Path([proxyShapePathSegment, spherePathSegment])
sphereItem = ufe.Hierarchy.createItem(spherePath)
# Get its Object3d interface.
object3d = ufe.Object3d.object3d(sphereItem)
# Get its bounding box.
ufeBBox = object3d.boundingBox()
# Compare it to known extents.
assertVectorAlmostEqual(self, ufeBBox.min.vector, [-1] * 3)
assertVectorAlmostEqual(self, ufeBBox.max.vector, [1] * 3)
# Remove the test file.
os.remove(usdFilePath)
def testRenameNotifications(self):
'''Rename a USD node and test for the UFE notifications.'''
# open usdCylinder.ma scene in test-samples
mayaUtils.openCylinderScene()
# clear selection to start off
cmds.select(clear=True)
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment(
'|world|mayaUsdTransform|shape')
usdPathSegment = usdUtils.createUfePathSegment('/pCylinder1')
cylinderPath = ufe.Path([mayaPathSegment, usdPathSegment])
cylinderItem = ufe.Hierarchy.createItem(cylinderPath)
ufe.GlobalSelection.get().append(cylinderItem)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# set the edit target to the root layer
stage.SetEditTarget(stage.GetRootLayer())
self.assertEqual(stage.GetEditTarget().GetLayer(),
stage.GetRootLayer())
# Create our UFE notification observer
ufeObs = TestObserver()
if (os.getenv('UFE_PREVIEW_VERSION_NUM', '0000') < '2021'):
# We start off with no observers
self.assertFalse(ufe.Scene.hasObjectAddObserver(ufeObs))
self.assertFalse(ufe.Scene.hasObjectDeleteObserver(ufeObs))
self.assertFalse(ufe.Scene.hasObjectPathChangeObserver(ufeObs))
# Add the UFE observers we want to test
ufe.Scene.addObjectAddObserver(ufeObs)
ufe.Scene.addObjectDeleteObserver(ufeObs)
ufe.Scene.addObjectPathChangeObserver(ufeObs)
else:
# We start off with no observers
self.assertFalse(ufe.Scene.hasObserver(ufeObs))
# Add the UFE observer we want to test
ufe.Scene.addObserver(ufeObs)
# rename
newName = 'pCylinder1_Renamed'
cmds.rename(newName)
# After the rename we should have 1 rename notif and no unexepected notifs.
self.assertEqual(ufeObs.notifications(), 1)
self.assertFalse(ufeObs.receivedUnexpectedNotif())
def testMultiSelectScaleUSD(self):
'''Scale multiple USD objects, read through Transform3d interface.'''
# Select multiple balls to scale them.
proxyShapePathSegment = mayaUtils.createUfePathSegment(
"|world|transform1|proxyShape1")
# Test passes for a single item.
# balls = ['Ball_33']
balls = ['Ball_33', 'Ball_34']
ballPaths = [
ufe.Path([proxyShapePathSegment,
usdUtils.createUfePathSegment('/Room_set/Props/'+ball)])
for ball in balls]
ballItems = [ufe.Hierarchy.createItem(ballPath)
for ballPath in ballPaths]
for ballItem in ballItems:
ufe.GlobalSelection.get().append(ballItem)
# We compare the UFE scale with the USD run-time scale. To
# obtain the full scale of USD scene items, we need to add the USD
# scale to the Maya proxy shape scale.
proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(0).node()
proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)
def usdSceneItemScale(item):
prim = usdUtils.getPrimFromSceneItem(item)
if not prim.HasAttribute('xformOp:scale'):
return proxyShapeXformFn.scale()
else:
return combineScales(proxyShapeXformFn.scale(), prim.GetAttribute('xformOp:scale').Get())
def ufeSceneItemScale(item):
return transform3dScale(ufe.Transform3d.transform3d(item))
# Set up the callables that will retrieve the scale.
self.runTimeScale = usdSceneItemScale
self.ufeScale = ufeSceneItemScale
# Give the tail item in the selection an initial scale that
# is different, to catch bugs where the relative scale
# incorrectly squashes any existing scale.
backItem = ballItems[-1]
backT3d = ufe.Transform3d.transform3d(backItem)
initialScale = [1.1, 2.2, 3.3]
backT3d.scale(*initialScale)
assertVectorAlmostEqual(self, initialScale, usdSceneItemScale(backItem), places=6)
# Save the initial positions to the memento list.
expected = [usdSceneItemScale(ballItem) for ballItem in ballItems]
self.runMultiSelectTestScale(ballItems, expected, places=6)
def testVisibility(self):
'''Test the Object3d visibility methods.'''
# Open top_layer.ma scene in test-samples
mayaUtils.openTopLayerScene()
# Get a scene item for Ball_35.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
# Create an Object3d interface for it.
object3d = ufe.Object3d.object3d(ball35Item)
visObs = TestObserver()
# We start off with no visibility observers.
self.assertFalse(ufe.Object3d.hasObserver(visObs))
self.assertEqual(ufe.Object3d.nbObservers(), 0)
# Set the observer for visibility changes.
ufe.Object3d.addObserver(visObs)
self.assertTrue(ufe.Object3d.hasObserver(visObs))
self.assertEqual(ufe.Object3d.nbObservers(), 1)
# No notifications yet.
self.assertEqual(visObs.notifications(), 0)
# Initially it should be visible.
self.assertTrue(object3d.visibility())
# Make it invisible.
object3d.setVisibility(False)
self.assertFalse(object3d.visibility())
# We should have got 'one' notification.
self.assertEqual(visObs.notifications(), 1)
# Make it visible.
object3d.setVisibility(True)
self.assertTrue(object3d.visibility())
# We should have got one more notification.
self.assertEqual(visObs.notifications(), 2)
# Remove the observer.
ufe.Object3d.removeObserver(visObs)
self.assertFalse(ufe.Object3d.hasObserver(visObs))
self.assertEqual(ufe.Object3d.nbObservers(), 0)
def runTestAttribute(self, path, attrName, ufeAttrClass, ufeAttrType):
'''Engine method to run attribute test.'''
# Create the UFE/USD attribute for this test from the input path.
# Get a UFE scene item the input path in the scene.
itemPath = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment(path)
])
ufeItem = ufe.Hierarchy.createItem(itemPath)
# Get the USD prim for this item.
usdPrim = usdUtils.getPrimFromSceneItem(ufeItem)
# Create the attributes interface for the item.
ufeAttrs = ufe.Attributes.attributes(ufeItem)
self.assertIsNotNone(ufeAttrs)
# Get the USDAttribute for the input attribute name so we can use it to
# compare to UFE.
usdAttr = usdPrim.GetAttribute(attrName)
self.assertIsNotNone(usdAttr)
# Get the attribute that matches the input name and make sure it matches
# the class type of UFE attribute class passed in.
self.assertTrue(ufeAttrs.hasAttribute(attrName))
ufeAttr = ufeAttrs.attribute(attrName)
self.assertIsInstance(ufeAttr, ufeAttrClass)
# Verify that the attribute type matches the input UFE type.
self.assertEqual(ufeAttr.type, ufeAttrType)
# Verify that the scene item the attribute was created with matches
# what is stored in the UFE attribute.
self.assertEqual(ufeAttr.sceneItem(), ufeItem)
# Verify that this attribute has a value. Note: all the attributes that
# are tested by this method are assumed to have a value.
self.assertTrue(ufeAttr.hasValue())
# Verify that the name matched what we created the attribute from.
self.assertEqual(ufeAttr.name, attrName)
# Test that the string representation of the value is not empty.
self.assertTrue(str(ufeAttr))
return ufeAttr, usdAttr
def testObservation(self):
'''Test Transform3d observation interface.
As of 11-Apr-2018 only implemented for USD objects.
'''
# Select Ball_35 to move it.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
# Create a Transform3d interface for it.
transform3d = ufe.Transform3d.transform3d(ball35Item)
t3dObs = TestObserver()
# We start off with no observers for Ball_35.
self.assertFalse(ufe.Transform3d.hasObservers(ball35Path))
self.assertFalse(ufe.Transform3d.hasObserver(ball35Item, t3dObs))
self.assertEqual(ufe.Transform3d.nbObservers(ball35Item), 0)
# Set the observer to observe Ball_35.
ufe.Transform3d.addObserver(ball35Item, t3dObs)
self.assertTrue(ufe.Transform3d.hasObservers(ball35Path))
self.assertTrue(ufe.Transform3d.hasObserver(ball35Item, t3dObs))
self.assertEqual(ufe.Transform3d.nbObservers(ball35Item), 1)
# No notifications yet.
self.assertEqual(t3dObs.notifications(), 0)
# We only select the ball AFTER doing our initial tests because
# the MayaUSD plugin creates a transform3d observer on selection
# change to update the bounding box.
ufe.GlobalSelection.get().append(ball35Item)
# Move the prim.
ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
ball35Prim.GetAttribute('xformOp:translate').Set(Gf.Vec3d(10, 20, 30))
# Notified.
self.assertEqual(t3dObs.notifications(), 1)
def testNodeTypes(self):
'''Engine method to run scene item test.'''
# Get a UFE scene item for one of the balls in the scene.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
# Ball35 is an Xform.
ball35NodeType = ball35Item.nodeType()
self.assertEqual(ball35NodeType, "Xform")
# This node type should be the first item on the ancestor node type list
# and it should have other items.
ball35AncestorNodeTypes = ball35Item.ancestorNodeTypes()
self.assertEqual(ball35NodeType, ball35AncestorNodeTypes[0])
self.assertTrue(len(ball35AncestorNodeTypes) > 1)
def testRotateUSD(self):
'''Rotate USD object, read through the Transform3d interface.'''
# Select Ball_35 to rotate it.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
ufe.GlobalSelection.get().append(ball35Item)
# Create a Transform3d interface for it.
transform3d = ufe.Transform3d.transform3d(ball35Item)
# We compare the UFE rotation with the USD run-time rotation. To
# obtain the full rotation of Ball_35, we need to add the USD
# rotation to the Maya proxy shape rotation.
proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(0).node()
proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)
def ball35Rotation():
ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
if not ball35Prim.HasAttribute('xformOp:rotateXYZ'):
return proxyShapeXformFn.rotation(om.MSpace.kTransform)
else:
x,y,z = ball35Prim.GetAttribute('xformOp:rotateXYZ').Get()
return proxyShapeXformFn.rotation(om.MSpace.kTransform) + om.MEulerRotation(radians(x), radians(y), radians(z))
# Set up the callables that will retrieve the rotation.
self.runTimeRotation = ball35Rotation
self.ufeRotation = partial(transform3dRotation, transform3d)
# Save the initial position to the memento list.
expected = ball35Rotation()
# MAYA-96058: unfortunately, rotate command currently requires a rotate
# manipulator to be created to update the UFE object.
manipCtx = cmds.manipRotateContext()
cmds.setToolTo(manipCtx)
#Temporarily disabling undo redo until we fix it for PR 94
self.runTestRotate(expected)
def testRenameProxyShape(self):
'''Rename proxy shape, UFE lookup should succeed.'''
mayaSegment = mayaUtils.createUfePathSegment(
"|world|transform1|proxyShape1")
usdSegment = usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
ball35Path = ufe.Path([mayaSegment, usdSegment])
ball35PathStr = ','.join(
[str(segment) for segment in ball35Path.segments])
# Because of difference in Python binding systems (pybind11 for UFE,
# Boost Python for mayaUsd and USD), need to pass in strings to
# mayaUsd functions. Multi-segment UFE paths need to have
# comma-separated segments.
def assertStageAndPrimAccess(proxyShapeSegment, primUfePathStr,
primSegment):
proxyShapePathStr = str(proxyShapeSegment)
stage = mayaUsd.ufe.getStage(proxyShapePathStr)
prim = mayaUsd.ufe.ufePathToPrim(primUfePathStr)
stagePath = mayaUsd.ufe.stagePath(stage)
self.assertIsNotNone(stage)
self.assertEqual(stagePath, proxyShapePathStr)
self.assertTrue(prim.IsValid())
self.assertEqual(str(prim.GetPath()), str(primSegment))
assertStageAndPrimAccess(mayaSegment, ball35PathStr, usdSegment)
# Rename the proxy shape node itself. Stage and prim access should
# still be valid, with the new path.
mayaSegment = mayaUtils.createUfePathSegment(
"|world|transform1|potato")
cmds.rename('|transform1|proxyShape1', 'potato')
self.assertEqual(len(cmds.ls('potato')), 1)
ball35Path = ufe.Path([mayaSegment, usdSegment])
ball35PathStr = ','.join(
[str(segment) for segment in ball35Path.segments])
assertStageAndPrimAccess(mayaSegment, ball35PathStr, usdSegment)
def testRenameSpecialCharacter(self):
# open twoSpheres.ma scene in test-samples
mayaUtils.openTwoSpheresScene()
# clear selection to start off
cmds.select(clear=True)
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment(
'|world|usdSphereParent|usdSphereParentShape')
usdPathSegment = usdUtils.createUfePathSegment('/sphereXform/sphere')
basePath = ufe.Path([mayaPathSegment, usdPathSegment])
usdSphereItem = ufe.Hierarchy.createItem(basePath)
ufe.GlobalSelection.get().append(usdSphereItem)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# by default edit target is set to the Rootlayer.
self.assertEqual(stage.GetEditTarget().GetLayer(),
stage.GetRootLayer())
# rename with special chars
newNameWithSpecialChars = '!@#%$@$=sph^e.re_*()<>}021|'
cmds.rename(newNameWithSpecialChars)
# get the prim
pSphereItem = ufe.GlobalSelection.get().front()
usdPrim = stage.GetPrimAtPath(str(pSphereItem.path().segments[1]))
self.assertTrue(usdPrim)
# prim names are not allowed to have special characters except '_'
regex = re.compile('[@!#$%^&*()<>?/\|}{~:]')
self.assertFalse(regex.search(usdPrim.GetName()))
# prim names are not allowed to start with digits
newNameStartingWithDigit = '09123Potato'
cmds.rename(newNameStartingWithDigit)
self.assertFalse(usdPrim.GetName()[0].isdigit())
def testUsdGroup(self):
'''Creation of USD group objects.'''
# Get parent of new group.
propsPath = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props")
])
propsItem = ufe.Hierarchy.createItem(propsPath)
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildrenPre = propsHierarchy.children()
groupPath = propsPath + "newGroup"
# Create new group.
group = propsHierarchy.createGroupCmd("newGroup")
self.assertIsNotNone(group.item)
# MAYA-92350: must re-create hierarchy interface object. Fix ASAP.
# PPT, 19-Nov-2018.
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildrenPost = propsHierarchy.children()
self.assertEqual(len(propsChildrenPre) + 1, len(propsChildrenPost))
childrenPaths = set([child.path() for child in propsChildrenPost])
self.assertTrue(groupPath in childrenPaths)
# Undo
group.undoableCommand.undo()
# MAYA-92350: must re-create hierarchy interface object. Fix ASAP.
# PPT, 19-Nov-2018.
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildrenPostUndo = propsHierarchy.children()
self.assertEqual(len(propsChildrenPre), len(propsChildrenPostUndo))
childrenPaths = set([child.path() for child in propsChildrenPostUndo])
self.assertFalse(groupPath in childrenPaths)
def testComboUSD(self):
'''Move, rotate, and scale USD object, read through the Transform3d interface.'''
# Select Ball_35 to move, rotate, and scale it.
ball35Path = ufe.Path([
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
])
ball35Item = ufe.Hierarchy.createItem(ball35Path)
ufe.GlobalSelection.get().append(ball35Item)
# Create a Transform3d interface for it.
transform3d = ufe.Transform3d.transform3d(ball35Item)
# We compare the UFE ops with the USD run-time ops. To
# obtain the full ops of Ball_35, we need to add the USD
# ops to the Maya proxy shape ops.
proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(
0).node()
proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)
def ball35Translation():
ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
return addVec(proxyShapeXformFn.translation(om.MSpace.kTransform),
ball35Prim.GetAttribute('xformOp:translate').Get())
def ball35Rotation():
ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
if not ball35Prim.HasAttribute('xformOp:rotateXYZ'):
return proxyShapeXformFn.rotation(om.MSpace.kTransform)
else:
x, y, z = ball35Prim.GetAttribute('xformOp:rotateXYZ').Get()
return proxyShapeXformFn.rotation(
om.MSpace.kTransform) + om.MEulerRotation(
radians(x), radians(y), radians(z))
def ball35Scale():
ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
if not ball35Prim.HasAttribute('xformOp:scale'):
return proxyShapeXformFn.scale()
else:
return combineScales(
proxyShapeXformFn.scale(),
ball35Prim.GetAttribute('xformOp:scale').Get())
# Set up the callables that will retrieve the translation.
self.runTimes[self.move] = ball35Translation
self.ufes[self.move] = partial(transform3dTranslation, transform3d)
# Set up the callables that will retrieve the rotation.
self.runTimes[self.rotate] = ball35Rotation
self.ufes[self.rotate] = partial(transform3dRotation, transform3d)
# Set up the callables that will retrieve the scale.
self.runTimes[self.scale] = ball35Scale
self.ufes[self.scale] = partial(transform3dScale, transform3d)
# Save the initial position to the memento list.
expectedTRS = None
if (self.move in self.ops):
v = ball35Translation()
expectedTRS = self.updateTRS(expectedTRS, self.move,
[v[0], v[1], v[2]])
if (self.rotate in self.ops):
r = ball35Rotation().asVector()
expectedTRS = self.updateTRS(
expectedTRS, self.rotate,
[degrees(r[0]), degrees(r[1]),
degrees(r[2])])
if (self.scale in self.ops):
s = ball35Scale()
expectedTRS = self.updateTRS(expectedTRS, self.scale,
[s[0], s[1], s[2]])
self.runTestCombo(expectedTRS)
def test_pickWalk(self):
'''
This test will be verify the use of Maya's pickWalk into Maya objects and Usd objects.
'''
# Initial state check up
self.snapShotAndTest()
# No Selection
cmds.pickWalk("pSphere1", d="down")
self.snapShotAndTest()
# Single Selection - Maya Item
cmds.select("pCube1")
self.snapShotAndTest()
cmds.pickWalk(d="down")
self.snapShotAndTest()
# Edge Case: Maya item to UFE Item
cmds.select("proxyShape1")
self.snapShotAndTest()
cmds.pickWalk(d="down") # /Room_set
self.snapShotAndTest(([], ['Room_set']))
# Edge Case: UFE Item to Maya
cmds.pickWalk(d="up") # /proxyShape1
self.snapShotAndTest()
# Pickwalk all the way down in USD - Pickwalk down again
for usdItem in ['Room_set', 'Props', 'Ball_1', 'mesh']:
cmds.pickWalk(d="down") # Room_set / Props / Ball_1 / mesh
self.snapShotAndTest(([], [usdItem]))
# Edge Case : Down on last item (Down again)
cmds.pickWalk(d="down")
self.snapShotAndTest(([], ['mesh']))
# Edge Case : Up on top item (Up again)
cmds.select("transform1")
self.snapShotAndTest()
cmds.pickWalk(d="up") # transform1
self.snapShotAndTest() # World is not selectable in maya
# Pickwalk on unsupported UFE items
cmds.select("pCube1.e[6]")
if int(cmds.about(majorVersion=True)) <= 2020:
self.snapShotAndTest((["pCube1.e[6]"], ["pCubeShape1"]))
self.assertTrue(next(iter(ufe.GlobalSelection.get())).isProperty())
else:
self.snapShotAndTest((["pCube1.e[6]"], []))
self.assertTrue(ufe.GlobalSelection.get().empty())
# TODO: HS 2019 : test fails. MAYA-101373
# cmds.pickWalk(type="edgeloop", d="right")
# import pdb; pdb.set_trace()
# self.snapShotAndTest((["pCube1.e[10]"], ["pCubeShape1"]))
# self.assertTrue(next(iter(ufe.GlobalSelection.get())).isProperty()) # pCubeShape1 in ufe selection is a property
# Pickwalk on Non-Mixed Maya items is already tested in Maya regression tests
# Pickwalk on Non-Mixed USD items
ufeUtils.selectPath(ufe.Path([ \
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"), \
usdUtils.createUfePathSegment("/Room_set/Props/Ball_1") \
]), True)
self.snapShotAndTest(([], ['Ball_1']))
ufeUtils.selectPath(ufe.Path([ \
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"), \
usdUtils.createUfePathSegment("/Room_set/Props/Ball_2") \
]))
self.snapShotAndTest(([], ['Ball_1', 'Ball_2']))
cmds.pickWalk(d="down")
self.snapShotAndTest(([], ['mesh', 'mesh']))
# Pickwalk on mixed items
ufeUtils.selectPath(ufe.Path([ \
mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"), \
usdUtils.createUfePathSegment("/Room_set/Props/Ball_1") \
]), True)
self.snapShotAndTest(([], ['Ball_1']))
ufeUtils.selectPath(ufe.Path(
mayaUtils.createUfePathSegment("|pCube1")))
self.snapShotAndTest((['pCube1'], ['Ball_1', 'pCube1']))
# Selection on Maya items from UFE does not work
cmds.pickWalk(d="down")
self.snapShotAndTest((['pCubeShape1'], ['mesh', 'pCubeShape1']))
# Test Complete - Undo and redo everything
''' MAYA-92081 : Undoing cmds.select does not restore the UFE selection.
def testUsdGroup(self):
'''Creation of USD group objects.'''
mayaPathSegment = mayaUtils.createUfePathSegment(
"|world|transform1|proxyShape1")
usdSegmentBall5 = usdUtils.createUfePathSegment(
"/Ball_set/Props/Ball_5")
ball5Path = ufe.Path([mayaPathSegment, usdSegmentBall5])
ball5Item = ufe.Hierarchy.createItem(ball5Path)
usdSegmentBall3 = usdUtils.createUfePathSegment(
"/Ball_set/Props/Ball_3")
ball3Path = ufe.Path([mayaPathSegment, usdSegmentBall3])
ball3Item = ufe.Hierarchy.createItem(ball3Path)
usdSegmentProps = usdUtils.createUfePathSegment("/Ball_set/Props")
parentPath = ufe.Path([mayaPathSegment, usdSegmentProps])
parentItem = ufe.Hierarchy.createItem(parentPath)
parentHierarchy = ufe.Hierarchy.hierarchy(parentItem)
parentChildrenPre = parentHierarchy.children()
self.assertEqual(len(parentChildrenPre), 6)
newGroupName = ufe.PathComponent("newGroup")
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# set the edit target to balls.usda
layer = stage.GetLayerStack()[1]
self.assertEqual("ballset.usda", layer.GetDisplayName())
stage.SetEditTarget(layer)
ufeSelectionList = ufe.Selection()
ufeSelectionList.append(ball5Item)
ufeSelectionList.append(ball3Item)
groupCmd = parentHierarchy.createGroupCmd(ufeSelectionList,
newGroupName)
groupCmd.execute()
parentChildrenPost = parentHierarchy.children()
self.assertEqual(len(parentChildrenPost), 5)
# The command will now append a number 1 at the end to match the naming
# convention in Maya.
newGroupPath = parentPath + ufe.PathComponent("newGroup1")
# Make sure the new group item has the correct Usd type
newGroupItem = ufe.Hierarchy.createItem(newGroupPath)
newGroupPrim = usdUtils.getPrimFromSceneItem(newGroupItem)
newGroupType = newGroupPrim.GetTypeName()
self.assertEqual(newGroupType, 'Xform')
childPaths = set([child.path() for child in parentChildrenPost])
self.assertTrue(newGroupPath in childPaths)
self.assertTrue(ball5Path not in childPaths)
self.assertTrue(ball3Path not in childPaths)
groupCmd.undo()
parentChildrenUndo = parentHierarchy.children()
self.assertEqual(len(parentChildrenUndo), 6)
childPathsUndo = set([child.path() for child in parentChildrenUndo])
self.assertTrue(newGroupPath not in childPathsUndo)
self.assertTrue(ball5Path in childPathsUndo)
self.assertTrue(ball3Path in childPathsUndo)
groupCmd.redo()
parentChildrenRedo = parentHierarchy.children()
self.assertEqual(len(parentChildrenRedo), 5)
childPathsRedo = set([child.path() for child in parentChildrenRedo])
self.assertTrue(newGroupPath in childPathsRedo)
self.assertTrue(ball5Path not in childPathsRedo)
self.assertTrue(ball3Path not in childPathsRedo)
def testRenameUndo(self):
'''Rename USD node.'''
# open usdCylinder.ma scene in test-samples
mayaUtils.openCylinderScene()
# clear selection to start off
cmds.select(clear=True)
# select a USD object.
mayaPathSegment = mayaUtils.createUfePathSegment(
'|world|mayaUsdTransform|shape')
usdPathSegment = usdUtils.createUfePathSegment('/pCylinder1')
cylinderPath = ufe.Path([mayaPathSegment, usdPathSegment])
cylinderItem = ufe.Hierarchy.createItem(cylinderPath)
cylinderHierarchy = ufe.Hierarchy.hierarchy(cylinderItem)
propsItem = cylinderHierarchy.parent()
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildrenPre = propsHierarchy.children()
ufe.GlobalSelection.get().append(cylinderItem)
# get the USD stage
stage = mayaUsd.ufe.getStage(str(mayaPathSegment))
# check GetLayerStack behavior
self.assertEqual(stage.GetLayerStack()[0], stage.GetSessionLayer())
self.assertEqual(stage.GetEditTarget().GetLayer(),
stage.GetRootLayer())
# by default edit target is set to the Rootlayer.
self.assertEqual(stage.GetEditTarget().GetLayer(),
stage.GetRootLayer())
# rename
cylinderItemType = cylinderItem.nodeType()
newName = 'pCylinder1_Renamed'
cmds.rename(newName)
# The renamed item is in the selection.
snIter = iter(ufe.GlobalSelection.get())
pCylinder1Item = next(snIter)
pCylinder1RenName = str(pCylinder1Item.path().back())
self.assertEqual(pCylinder1RenName, newName)
propsChildren = propsHierarchy.children()
self.assertEqual(len(propsChildren), len(propsChildrenPre))
self.assertIn(pCylinder1Item, propsChildren)
cmds.undo()
self.assertEqual(cylinderItemType,
ufe.GlobalSelection.get().back().nodeType())
def childrenNames(children):
return [str(child.path().back()) for child in children]
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildren = propsHierarchy.children()
propsChildrenNames = childrenNames(propsChildren)
self.assertNotIn(pCylinder1RenName, propsChildrenNames)
self.assertIn('pCylinder1', propsChildrenNames)
self.assertEqual(len(propsChildren), len(propsChildrenPre))
cmds.redo()
self.assertEqual(cylinderItemType,
ufe.GlobalSelection.get().back().nodeType())
propsHierarchy = ufe.Hierarchy.hierarchy(propsItem)
propsChildren = propsHierarchy.children()
propsChildrenNames = childrenNames(propsChildren)
self.assertIn(pCylinder1RenName, propsChildrenNames)
self.assertNotIn('pCylinder1', propsChildrenNames)
self.assertEqual(len(propsChildren), len(propsChildrenPre))
