def testNext(self):
a = GafferTest.AddNode()
n = Gaffer.Node()
n["a1"] = Gaffer.ArrayPlug(element=Gaffer.IntPlug())
n["a2"] = Gaffer.ArrayPlug(element=Gaffer.IntPlug(),
maxSize=3,
resizeWhenInputsChange=False)
self.assertEqual(len(n["a1"]), 1)
self.assertEqual(len(n["a2"]), 1)
self.assertEqual(n["a1"].next(), n["a1"][0])
self.assertEqual(n["a2"].next(), n["a2"][0])
n["a1"][0].setInput(a["sum"])
n["a2"][0].setInput(a["sum"])
self.assertEqual(len(n["a1"]), 2)
self.assertEqual(len(n["a2"]), 1)
self.assertEqual(n["a1"].next(), n["a1"][1])
self.assertEqual(n["a2"].next(), n["a2"][1])
self.assertEqual(len(n["a2"]), 2)
self.assertEqual(n["a1"].next(), n["a1"][1])
self.assertEqual(n["a2"].next(), n["a2"][1])
n["a2"].next().setInput(a["sum"])
n["a2"].next().setInput(a["sum"])
self.assertEqual(len(n["a2"]), 3)
self.assertEqual(n["a2"].next(), None)
def testArrayPlug( self ) : n1 = Gaffer.Node() n1["a"] = Gaffer.ArrayPlug( element = Gaffer.IntPlug() ) n2 = Gaffer.Node() n2["a"] = Gaffer.ArrayPlug( element = Gaffer.IntPlug() ) d = Gaffer.Dot() d.setup( n1["a"] ) d["in"].setInput( n1["a"] ) n2["a"].setInput( d["out"] ) self.assertEqual( len( d["out"] ), 1 ) self.assertTrue( d["out"].source().isSame( n1["a"] ) ) self.assertTrue( d["out"][0].source().isSame( n1["a"][0] ) ) i = Gaffer.IntPlug() n1["a"][0].setInput( i ) self.assertEqual( len( n1["a"] ), 2 ) self.assertEqual( len( d["in"] ), 2 ) self.assertEqual( len( d["out"] ), 2 ) self.assertTrue( d["out"].source().isSame( n1["a"] ) ) self.assertTrue( d["out"][0].source().isSame( i ) ) self.assertTrue( d["out"][1].source().isSame( n1["a"][1] ) )
def testTopLevelConnection(self):
n = Gaffer.Node()
n["a"] = Gaffer.ArrayPlug(element=Gaffer.IntPlug())
n["b"] = Gaffer.ArrayPlug(element=Gaffer.IntPlug())
n["b"].setInput(n["a"])
def assertInput(plug, input):
self.assertEqual(len(plug), len(input))
for i in range(0, len(plug)):
self.assertTrue(plug[i].getInput().isSame(input[i]))
assertInput(n["b"], n["a"])
a = GafferTest.AddNode()
n["a"][0].setInput(a["sum"])
self.assertEqual(len(n["a"]), 2)
assertInput(n["b"], n["a"])
n["a"][1].setInput(a["sum"])
self.assertEqual(len(n["a"]), 3)
assertInput(n["b"], n["a"])
n["a"][0].setInput(None)
self.assertEqual(len(n["a"]), 3)
assertInput(n["b"], n["a"])
def testDependencyNodeSwitch( self ) : n = Gaffer.SwitchDependencyNode() n["in"] = Gaffer.ArrayPlug( element = Gaffer.Plug(), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) n["out"] = Gaffer.Plug( direction = Gaffer.Plug.Direction.Out, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) self.assertTrue( n["out"].source().isSame( n["in"][0] ) ) input0 = Gaffer.Plug() input1 = Gaffer.Plug() input2 = Gaffer.Plug() n["in"][0].setInput( input0 ) self.assertTrue( n["out"].source().isSame( input0 ) ) n["in"][1].setInput( input1 ) self.assertTrue( n["out"].source().isSame( input0 ) ) n["index"].setValue( 1 ) self.assertTrue( n["out"].source().isSame( input1 ) ) n["enabled"].setValue( False ) self.assertTrue( n["out"].source().isSame( input0 ) ) n["in"][2].setInput( input2 ) self.assertTrue( n["out"].source().isSame( input0 ) ) n["enabled"].setValue( True ) self.assertTrue( n["out"].source().isSame( input1 ) ) n["index"].setValue( 2 ) self.assertTrue( n["out"].source().isSame( input2 ) )
def colorSwitch( self ) : result = Gaffer.SwitchComputeNode() result["in"] = Gaffer.ArrayPlug( element = Gaffer.Color3fPlug(), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) result["out"] = Gaffer.Color3fPlug( direction = Gaffer.Plug.Direction.Out, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) return result
def testIndirectInputsToIndex(self):
n = Gaffer.Switch()
n["in"] = Gaffer.ArrayPlug(element=Gaffer.Plug(),
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
n["out"] = Gaffer.Plug(direction=Gaffer.Plug.Direction.Out,
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
input0 = Gaffer.Plug()
input1 = Gaffer.Plug()
input2 = Gaffer.Plug()
n["in"][0].setInput(input0)
n["in"][1].setInput(input1)
n["in"][2].setInput(input2)
self.assertTrue(n["out"].source().isSame(input0))
indexInput = Gaffer.IntPlug()
n["index"].setInput(indexInput)
self.assertTrue(n["out"].source().isSame(input0))
indirectIndexInput1 = Gaffer.IntPlug(defaultValue=1)
indirectIndexInput2 = Gaffer.IntPlug(defaultValue=2)
indexInput.setInput(indirectIndexInput1)
self.assertTrue(n["out"].source().isSame(input1))
indexInput.setInput(indirectIndexInput2)
self.assertTrue(n["out"].source().isSame(input2))
def testMinimumInputs(self):
a = GafferTest.AddNode()
n = Gaffer.Node()
n["in"] = Gaffer.ArrayPlug("in",
element=Gaffer.IntPlug("e1"),
minSize=3)
self.assertEqual(len(n["in"]), 3)
# connecting to the middle input shouldn't create
# any new inputs, because there is still one free on the end
n["in"]["e2"].setInput(a["sum"])
self.assertEqual(len(n["in"]), 3)
# connecting to the last input should create a new
# one - there should always be one free input on the
# end (until the maximum is reached).
n["in"]["e3"].setInput(a["sum"])
self.assertEqual(len(n["in"]), 4)
n["in"]["e3"].setInput(None)
self.assertEqual(len(n["in"]), 3)
def testFixedLengthDynamic(self):
s = Gaffer.ScriptNode()
s["a"] = GafferTest.AddNode()
s["n"] = Gaffer.Node()
s["n"]["a"] = Gaffer.ArrayPlug("a",
element=Gaffer.IntPlug(),
minSize=4,
maxSize=4,
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["n"]["a"][1].setInput(s["a"]["sum"])
s["n"]["a"][2].setInput(s["a"]["sum"])
self.assertEqual(s["n"]["a"].minSize(), 4)
self.assertEqual(s["n"]["a"].maxSize(), 4)
self.assertEqual(len(s["n"]["a"]), 4)
self.assertTrue(s["n"]["a"][0].getInput() is None)
self.assertTrue(s["n"]["a"][1].getInput().isSame(s["a"]["sum"]))
self.assertTrue(s["n"]["a"][1].getInput().isSame(s["a"]["sum"]))
self.assertTrue(s["n"]["a"][3].getInput() is None)
s2 = Gaffer.ScriptNode()
s2.execute(s.serialise())
self.assertEqual(s2["n"]["a"].minSize(), 4)
self.assertEqual(s2["n"]["a"].maxSize(), 4)
self.assertEqual(len(s2["n"]["a"]), 4)
self.assertTrue(s2["n"]["a"][0].getInput() is None)
self.assertTrue(s2["n"]["a"][1].getInput().isSame(s2["a"]["sum"]))
self.assertTrue(s2["n"]["a"][1].getInput().isSame(s2["a"]["sum"]))
self.assertTrue(s2["n"]["a"][3].getInput() is None)
def testNumberOfInputs(self):
n = GafferImage.ImageProcessor()
self.assertTrue(isinstance(n["in"], GafferImage.ImagePlug))
n = GafferImage.ImageProcessor(minInputs=2, maxInputs=2)
self.assertTrue(isinstance(n["in"], Gaffer.ArrayPlug))
self.assertEqual(len(n["in"]), 2)
self.assertTrue(isinstance(n["in"][0], GafferImage.ImagePlug))
self.assertTrue(isinstance(n["in"][1], GafferImage.ImagePlug))
self.assertEqual(n["in"].minSize(), 2)
self.assertEqual(n["in"].maxSize(), 2)
n = GafferImage.ImageProcessor(minInputs=2, maxInputs=1000)
self.assertTrue(isinstance(n["in"], Gaffer.ArrayPlug))
self.assertTrue(isinstance(n["in"][0], GafferImage.ImagePlug))
self.assertTrue(isinstance(n["in"][1], GafferImage.ImagePlug))
self.assertEqual(len(n["in"]), 2)
self.assertEqual(n["in"].minSize(), 2)
self.assertEqual(n["in"].maxSize(), 1000)
n = GafferImage.ImageProcessor(minInputs=2)
self.assertTrue(isinstance(n["in"], Gaffer.ArrayPlug))
self.assertTrue(isinstance(n["in"][0], GafferImage.ImagePlug))
self.assertTrue(isinstance(n["in"][1], GafferImage.ImagePlug))
self.assertEqual(len(n["in"]), 2)
self.assertEqual(n["in"].minSize(), 2)
self.assertEqual(n["in"].maxSize(), Gaffer.ArrayPlug().maxSize())
def testReloadWithNestedInputConnections(self):
s = Gaffer.ScriptNode()
s["b"] = Gaffer.Box()
s["b"]["array"] = Gaffer.ArrayPlug(element=Gaffer.IntPlug(),
flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["b"]["color"] = Gaffer.Color3fPlug(flags=Gaffer.Plug.Flags.Default
| Gaffer.Plug.Flags.Dynamic)
s["b"].exportForReference(self.temporaryDirectory() + "/test.grf")
s["a"] = GafferTest.AddNode()
s["r"] = Gaffer.Reference()
s["r"].load(self.temporaryDirectory() + "/test.grf")
s["r"]["array"][0].setInput(s["a"]["sum"])
s["r"]["array"][1].setInput(s["a"]["sum"])
s["r"]["color"]["g"].setInput(s["a"]["sum"])
s["r"].load(self.temporaryDirectory() + "/test.grf")
self.assertTrue(s["r"]["array"][0].getInput().isSame(s["a"]["sum"]))
self.assertTrue(s["r"]["array"][1].getInput().isSame(s["a"]["sum"]))
self.assertTrue(s["r"]["color"]["g"].getInput().isSame(s["a"]["sum"]))
def __init__(self, name="ArrayPlugNode"):
Gaffer.Node.__init__(self, name)
self.addChild(
Gaffer.ArrayPlug("in",
element=Gaffer.IntPlug("e1",
minValue=0,
maxValue=10),
maxSize=6))
def __init__(self, name="maya"):
from mergeNode import Merge
super(mayaScene, self).__init__(name)
self['RendermanIPR'] = Gaffer.IntPlug(
defaultValue=GafferScene.InteractiveRender.State.Stopped,
flags=Gaffer.Plug.Flags.Default & ~Gaffer.Plug.Flags.Serialisable)
# self.addChild( GafferScene.ScenePlug( "out", Gaffer.Plug.Direction.Out ) )
self.addChild(
Gaffer.ArrayPlug("in",
Gaffer.Plug.Direction.In,
element=GafferScene.ScenePlug("in0")))
# self.addChild( GafferScene.ScenePlug( "sceneIn", Gaffer.Plug.Direction.In ) )
self['progressBar'] = Gaffer.V2iPlug(defaultValue=IECore.V2i(0, 1),
flags=Gaffer.Plug.Flags.Default
& ~Gaffer.Plug.Flags.Serialisable)
self['progressBarMayaPY'] = Gaffer.V2iPlug(
defaultValue=IECore.V2i(0, 1),
flags=Gaffer.Plug.Flags.Default & ~Gaffer.Plug.Flags.Serialisable)
self['progressBarSceneLoad'] = Gaffer.V2iPlug(
defaultValue=IECore.V2i(0, 1),
flags=Gaffer.Plug.Flags.Default & ~Gaffer.Plug.Flags.Serialisable)
self['progressBarIPR'] = Gaffer.V2iPlug(
defaultValue=IECore.V2i(0, 1),
flags=Gaffer.Plug.Flags.Default & ~Gaffer.Plug.Flags.Serialisable)
self['AutomaticallyUpdateGeometry'] = Gaffer.BoolPlug(
defaultValue=True)
self.stopMayapy()
self.timer = QtCore.QTimer()
# self.addChild( Gaffer.StringPlug( "fileName" ) )
# self.addChild( Gaffer.ObjectPlug( "out", Gaffer.Plug.Direction.Out, IECore.NullObject.defaultNullObject() ) )
# self.addChild( Gaffer.ScenePlug( "scene", Gaffer.Plug.Direction.Out, IECore.NullScene.defaultNullScene() ) )
self.currentFrame = 10
self['__merge'] = Merge()
self['__merge']['in'].setInput(self['in'])
self["out"].setInput(self["__merge"]["out"])
self.stopMayapy()
self.__last_c_transfrom = None
def __createNode( name ) : node = Gaffer.Node() node.setName( name.replace( ".", "_" ) ) node["preTasks"] = Gaffer.ArrayPlug( element = Gaffer.Plug( "preTask0" ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) node["task"] = Gaffer.Plug( direction = Gaffer.Plug.Direction.Out, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) node["node"] = Gaffer.StringPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) node["frames"] = Gaffer.StringPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) node["context"] = Gaffer.StringPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) Gaffer.Metadata.registerValue( node["preTasks"], "nodule:type", "GafferUI::CompoundNodule" ) for n in "node", "frames", "context" : Gaffer.Metadata.registerValue( node[n], "nodule:type", "" ) return node
def testResizeWhenInputsChange( self ) : s = Gaffer.ScriptNode() s["a"] = GafferTest.AddNode() s["n"] = Gaffer.Node() s["n"]["user"]["p"] = Gaffer.ArrayPlug( element = Gaffer.IntPlug(), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic, resizeWhenInputsChange = False ) self.assertEqual( s["n"]["user"]["p"].resizeWhenInputsChange(), False ) self.assertEqual( len( s["n"]["user"]["p"] ), 1 ) s["n"]["user"]["p"][0].setInput( s["a"]["sum"] ) self.assertEqual( len( s["n"]["user"]["p"] ), 1 ) s["n"]["user"]["p"][0].setInput( None ) self.assertEqual( len( s["n"]["user"]["p"] ), 1 ) p = s["n"]["user"]["p"].createCounterpart( "p", Gaffer.Plug.Direction.In ) self.assertEqual( p.resizeWhenInputsChange(), False )
def testResize( self ) : p = Gaffer.ArrayPlug( element = Gaffer.IntPlug(), minSize = 1, maxSize = 3, resizeWhenInputsChange = False ) self.assertEqual( len( p ), p.minSize() ) p.resize( 2 ) self.assertEqual( len( p ), 2 ) self.assertIsInstance( p[1], Gaffer.IntPlug ) p.resize( 3 ) self.assertEqual( len( p ), 3 ) self.assertIsInstance( p[2], Gaffer.IntPlug ) with self.assertRaises( RuntimeError ) : p.resize( p.minSize() - 1 ) with self.assertRaises( RuntimeError ) : p.resize( p.maxSize() + 1 )
def __init__(self, name="none"):
super(samAssetNode, self).__init__(name)
self['asset'] = Gaffer.StringPlug()
Gaffer.MetadataAlgo.setReadOnly(self['asset'], True)
self['name'] = Gaffer.StringPlug()
Gaffer.MetadataAlgo.setReadOnly(self['name'], True)
self['overrideAssetMask'] = Gaffer.StringPlug()
Gaffer.MetadataAlgo.setReadOnly(self['overrideAssetMask'], True)
self['out'] = Gaffer.StringPlug("out", Gaffer.Plug.Direction.Out, "")
# self.addChild( Gaffer.StringPlug( "out", Gaffer.Plug.Direction.Out, "" ) )
self['in'] = Gaffer.ArrayPlug("in",
Gaffer.Plug.Direction.In,
element=Gaffer.StringPlug("in0"))
self['enabled'] = Gaffer.BoolPlug()
self['enabled'].setValue(True)
def testArrayPlugCopiesColors( self ) :
n = Gaffer.Node()
n2 = Gaffer.Node()
n2.addChild(Gaffer.IntPlug("test"))
connectionColor = IECore.Color3f( 0.1 , 0.2 , 0.3 )
noodleColor = IECore.Color3f( 0.4, 0.5 , 0.6 )
element = Gaffer.IntPlug()
Gaffer.Metadata.registerValue( element, "connectionGadget:color", connectionColor )
Gaffer.Metadata.registerValue( element, "nodule:color", noodleColor )
n["a"] = Gaffer.ArrayPlug( element = element )
n["a"][0].setInput(n2["test"])
self.assertEqual( Gaffer.Metadata.value( n["a"][1], "connectionGadget:color" ), connectionColor )
self.assertEqual( Gaffer.Metadata.value( n["a"][1], "nodule:color" ), noodleColor )
def __init__(self, name="Merge"):
super(Merge, self).__init__(name)
self['in'] = Gaffer.ArrayPlug("in",
Gaffer.Plug.Direction.In,
element=GafferScene.ScenePlug("in0"))
# group in and this node into the scene
self["__group0"] = GafferScene.Group()
self["__group0"]["enabled"].setInput(self["enabled"])
self["__group0"]["in"].setInput(self["in"])
# remove the group and parent the nodes back to root
self["__subtree"] = GafferScene.SubTree()
self["__subtree"]["enabled"].setInput(self["enabled"])
self["__subtree"]['root'].setValue('/group')
self["__subtree"]['in'].setInput(self["__group0"]['out'])
self["out"].setInput(self["__subtree"]["out"])
def testPythonElement( self ) : class PythonElement( Gaffer.Plug ) : def __init__( self, name = "PythonElement", direction = Gaffer.Plug.Direction.In, flags = Gaffer.Plug.Flags.Default ) : Gaffer.Plug.__init__( self, name, direction, flags ) def createCounterpart( self, name, direction ) : return PythonElement( name, direction, self.getFlags() ) n = Gaffer.Node() n["a"] = Gaffer.ArrayPlug( element = PythonElement() ) self.assertEqual( len( n["a"] ), 1 ) self.assertTrue( isinstance( n["a"][0], PythonElement ) ) p = PythonElement() n["a"][0].setInput( p ) self.assertEqual( len( n["a"] ), 2 ) self.assertTrue( isinstance( n["a"][1], PythonElement ) )
def testPartialConnections(self):
n = Gaffer.Node()
n["p"] = Gaffer.ArrayPlug(element=Gaffer.V3fPlug("e"))
self.assertEqual(len(n["p"]), 1)
p = Gaffer.FloatPlug()
n["p"][0]["x"].setInput(p)
self.assertEqual(len(n["p"]), 2)
n["p"][0]["y"].setInput(p)
self.assertEqual(len(n["p"]), 2)
n["p"][1]["y"].setInput(p)
self.assertEqual(len(n["p"]), 3)
n["p"][2]["z"].setInput(p)
self.assertEqual(len(n["p"]), 4)
n["p"][1]["y"].setInput(None)
self.assertEqual(len(n["p"]), 4)
n["p"][2]["z"].setInput(None)
self.assertEqual(len(n["p"]), 2)
def testDenyInputFromNonArrayPlugs(self):
a = Gaffer.ArrayPlug(element=Gaffer.IntPlug())
p = Gaffer.V2iPlug()
self.assertFalse(a.acceptsInput(p))
def __init__(self, name="none"):
GafferScene.SceneNode.__init__(self, name)
self['asset'] = Gaffer.StringPlug('asset', Gaffer.Plug.Direction.In,
'')
Gaffer.MetadataAlgo.setReadOnly(self['asset'], True)
self['name'] = Gaffer.StringPlug()
Gaffer.MetadataAlgo.setReadOnly(self['name'], True)
self['camera'] = Gaffer.StringVectorDataPlug(
'camera', Gaffer.Plug.Direction.In, IECore.StringVectorData([]))
Gaffer.MetadataAlgo.setReadOnly(self['name'], True)
self['alembic'] = Gaffer.StringPlug()
Gaffer.MetadataAlgo.setReadOnly(self['name'], True)
self['overrideAssetMask'] = Gaffer.StringPlug()
Gaffer.MetadataAlgo.setReadOnly(self['overrideAssetMask'], True)
self['previewAlembic'] = Gaffer.BoolPlug('previewAlembic',
Gaffer.Plug.Direction.In,
True)
# a input scene nodule, so we can connect another asset to this one
# useful to connect shader to model/animation
self['in'] = Gaffer.ArrayPlug("in",
Gaffer.Plug.Direction.In,
element=GafferScene.ScenePlug("in0"))
# we use this to convert the asset parameter to a gaffer name
class logic(genericComputeNode):
''' we use this small python compute node to do some logic in the sceneNode.
Basically it works like an expression, which uses the value of "asset" plug to setup
the internal alembicSource node so alembic shows up in the viewer.
it also sets the name of our node, so it shows up in the hierarchy list.
'''
def _init(self):
# self.add( GafferScene.ScenePlug( "inScene", Gaffer.Plug.Direction.In ) )
self.add(
GafferScene.ScenePlug("alembic", Gaffer.Plug.Direction.In))
self.add(
GafferScene.ScenePlug("enable", Gaffer.Plug.Direction.In))
self.add(
Gaffer.StringPlug("inAsset", Gaffer.Plug.Direction.In, ""))
self.add(
Gaffer.StringPlug("out", Gaffer.Plug.Direction.Out, ""))
self.add(
Gaffer.StringPlug("outABC", Gaffer.Plug.Direction.Out, ""))
self.add(
Gaffer.StringPlug("outCAMERA", Gaffer.Plug.Direction.Out,
""))
self.add(
Gaffer.StringVectorDataPlug("outCAMERAs",
Gaffer.Plug.Direction.Out,
IECore.StringVectorData([])))
self.add(
Gaffer.BoolPlug("outCAMERAenable",
Gaffer.Plug.Direction.Out))
self.add(
Gaffer.StringPlug("outCAMERA_proj",
Gaffer.Plug.Direction.Out, ""))
self.add(
Gaffer.FloatPlug("outCAMERA_fov",
Gaffer.Plug.Direction.Out))
self.add(
Gaffer.FloatPlug("outModelAsset",
Gaffer.Plug.Direction.Out))
# self.add( Gaffer.StringPlug( "out2", Gaffer.Plug.Direction.Out, "" ) )
# self.add( GafferScene.ScenePlug( "outScene", Gaffer.Plug.Direction.Out ) )
def _compute(cls, plug, context):
import utils
# print '===>',cls['in'].getValue()
assetPath = str(cls['inAsset'].getValue())
asset = assetPath.split('/')
def getCameras(scene, path, l=[]):
for childName in scene.childNames(path):
if scene.object(path + '/' +
str(childName)).typeName() == 'Camera':
l += [path + '/' + str(childName)]
l[-1] = l[-1].replace('//', '/')
getCameras(scene, path + '/' + str(childName), l)
return l
if not asset[0]:
asset = ['unnamed', 'unnamed', 'unnamed']
node = self["__alembic"]
# if plug.isSame( self['out'] ) :
if plug.isSame(cls['out']):
cls['out'].setValue(utils.samAssetToGaffer(assetPath))
elif plug.isSame(cls['outCAMERAenable']):
cls['outCAMERAenable'].setValue(False)
if asset[1] in ['alembic'] and asset[0] in ['camera']:
for camera in getCameras(node["out"], "/"):
cls['outCAMERAenable'].setValue(True)
elif plug.isSame(cls['outCAMERA']):
if asset[1] in ['alembic'] and asset[0] in ['camera']:
cameras = []
for camera in getCameras(node["out"], "/"):
cameras += [
utils.samAssetToGaffer(assetPath) + '/' +
camera
]
cls['outCAMERA'].setValue(cameras[-1])
else:
cls['outCAMERA'].setValue('no camera found')
elif plug.isSame(cls['outCAMERAs']):
cameras = []
if asset[1] in ['alembic'] and asset[0] in ['camera']:
for camera in getCameras(node["out"], "/"):
cameras += [camera]
cls['outCAMERAs'].setValue(
IECore.StringVectorData(cameras))
elif plug.isSame(cls['outCAMERA_proj']):
if asset[1] in ['alembic'] and asset[0] in ['camera']:
for camera in getCameras(node["out"], "/"):
cls['outCAMERA_proj'].setValue(
str(node["out"].object(camera).parameters()
['projection']))
elif plug.isSame(cls['outCAMERA_fov']):
if asset[1] in ['alembic'] and asset[0] in ['camera']:
for camera in getCameras(node["out"], "/"):
cls['outCAMERA_fov'].setValue(
float(node["out"].object(camera).parameters()
['projection:fov']))
elif plug.isSame(cls['outABC']):
if asset[1] in ['alembic']:
cls['outABC'].setValue(
assetUtils.assetOP(
assetPath).data['multiplePublishedFiles'][0])
else:
cls['outABC'].setValue("")
elif plug.isSame(cls['outModelAsset']):
if asset[0] in ['model']:
cls['outModelAsset'].setValue(0)
else:
cls['outModelAsset'].setValue(1)
self["__computeNode"] = logic(self.getName() + '_computeNode')
self["__computeNode"]['inAsset'].setInput(self['asset'])
# self["__computeNode"]['inScene'].setInput( self['in'] )
# self["__computeNode"]._compute = _compute #lambda cls, plug, context: self["__computeNode"]['out'].setValue(str( self['in'][0].getValue() ).replace('/',' | '))
self['name'].setInput(self["__computeNode"]['out'])
self['camera'].setInput(self["__computeNode"]['outCAMERAs'])
self['alembic'].setInput(self["__computeNode"]['outABC'])
self["__alembic"] = GafferScene.AlembicSource()
self["__alembic"]["enabled"].setInput(self["previewAlembic"])
self["__alembic"]['fileName'].setInput(self["__computeNode"]['outABC'])
self["__alembicTimeWarp"] = GafferScene.SceneTimeWarp()
self["__alembicTimeWarp"]['speed'].setInput(
self["__computeNode"]['outModelAsset'])
self["__alembicTimeWarp"]['in'].setInput(self['__alembic']['out'])
self["__cameraSet"] = GafferScene.Set()
self["__cameraSet"]['mode'].setValue(1)
self["__cameraSet"]['name'].setValue('__cameras')
self["__cameraSet"]['paths'].setInput(
self["__computeNode"]['outCAMERAs'])
self["__cameraSet"]['in'].setInput(self['__alembicTimeWarp']['out'])
self["__obj"] = GafferScene.ObjectToScene()
self["__obj"]["enabled"].setInput(self["enabled"])
self["__obj"]['name'].setInput(self["__computeNode"]['out'])
self["__obj"]['sets'].setValue("assetList")
self["__parent"] = GafferScene.Parent()
self["__parent"]['in'].setInput(self['__obj']['out'])
self["__parent"]['child'].setInput(self['__cameraSet']['out'])
self["__parent"]['parent'].setInput(self["__computeNode"]['out'])
# we use this group0/subtree0 to connect the compound input of this node into our sub network
self["__group0"] = GafferScene.Group()
self["__group0"]["enabled"].setInput(self["enabled"])
self["__group0"]["in"].setInput(self["in"])
# remove the group and parent the nodes back to root
self["__subtree0"] = GafferScene.SubTree()
self["__subtree0"]["enabled"].setInput(self["enabled"])
self["__subtree0"]['root'].setValue('/group')
self["__subtree0"]['in'].setInput(self["__group0"]['out'])
# group1/subtree1 merges the inputs with the internal network scene
self["__group1"] = GafferScene.Group()
self["__group1"]["enabled"].setInput(self["enabled"])
self["__group1"]["in"][0].setInput(self["__subtree0"]['out'])
self["__group1"]["in"][1].setInput(self["__parent"]["out"])
# self["__group0"]["in"][2].setInput( self["__alembic"]['out'] )
# remove the group and parent the nodes back to root
self["__subtree1"] = GafferScene.SubTree()
self["__subtree1"]["enabled"].setInput(self["enabled"])
self["__subtree1"]['root'].setValue('/group')
self["__subtree1"]['in'].setInput(self["__group1"]['out'])
self["out"].setInput(self["__subtree1"]["out"])
def testOnlyOneChildType(self):
p = Gaffer.ArrayPlug(element=Gaffer.IntPlug())
self.assertTrue(p.acceptsChild(Gaffer.IntPlug()))
self.assertFalse(p.acceptsChild(Gaffer.FloatPlug()))
