def test(self): n = Gaffer.Node() n["user"]["p1"] = Gaffer.BoolPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) n["user"]["p2"] = Gaffer.BoolPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) w = GafferUI.BoolPlugValueWidget(n["user"]["p1"]) self.assertEqual(w.getPlug(), n["user"]["p1"]) self.assertEqual(w.getPlugs(), {n["user"]["p1"]}) self.assertEqual(w.boolWidget().getState(), False) n["user"]["p1"].setValue(True) self.assertEqual(w.boolWidget().getState(), True) w.setPlugs(n["user"].children()) self.assertEqual(w.boolWidget().getState(), w.boolWidget().State.Indeterminate) n["user"]["p2"].setValue(True) self.assertEqual(w.boolWidget().getState(), True) w.setPlugs([]) self.assertEqual(w.boolWidget().getState(), w.boolWidget().State.Indeterminate)
def __init__(self, name="MtlXInput"): """ @param name: str """ GafferScene.SceneNode.__init__(self, name) # Status string self.status = str() # MaterialX document object self.mtlx_doc = None self["mtlXPath"] = Gaffer.StringPlug() self["refresh"] = Gaffer.IntPlug() self["mtlXLook"] = Gaffer.IntPlug() self["resolved"] = Gaffer.StringPlug() self["status"] = Gaffer.StringPlug("status", Gaffer.Plug.Direction.Out) self["applyMaterials"] = Gaffer.BoolPlug(defaultValue=True) self["applyAssignments"] = Gaffer.BoolPlug(defaultValue=True) self["applyAttributes"] = Gaffer.BoolPlug(defaultValue=True) self["in"] = GafferScene.ScenePlug("in", Gaffer.Plug.Direction.In, flags=Gaffer.Plug.Flags.Default) self["out"] = GafferScene.ScenePlug("out", Gaffer.Plug.Direction.Out) self["out"].setInput(self["in"]) self.plugSetSignal().connect(self.plug_set, scoped=False)
def _setupPlugs(parent_plug): if "deadline" in parent_plug: return parent_plug["deadline"] = Gaffer.Plug() parent_plug["deadline"]["comment"] = Gaffer.StringPlug() parent_plug["deadline"]["department"] = Gaffer.StringPlug() parent_plug["deadline"]["pool"] = Gaffer.StringPlug() parent_plug["deadline"]["secondaryPool"] = Gaffer.StringPlug() parent_plug["deadline"]["group"] = Gaffer.StringPlug() parent_plug["deadline"]["priority"] = Gaffer.IntPlug(defaultValue=50, minValue=0, maxValue=100) parent_plug["deadline"]["taskTimeout"] = Gaffer.IntPlug(defaultValue=0, minValue=0) parent_plug["deadline"]["enableAutoTimeout"] = Gaffer.BoolPlug(defaultValue=False) parent_plug["deadline"]["concurrentTasks"] = Gaffer.IntPlug(defaultValue=1, minValue=1, maxValue=16) parent_plug["deadline"]["machineLimit"] = Gaffer.IntPlug(defaultValue=0, minValue=0) parent_plug["deadline"]["machineList"] = Gaffer.StringPlug() parent_plug["deadline"]["isBlackList"] = Gaffer.BoolPlug(defaultValue=False) parent_plug["deadline"]["limits"] = Gaffer.StringPlug() parent_plug["deadline"]["onJobComplete"] = Gaffer.StringPlug() parent_plug["deadline"]["onJobComplete"].setValue("Nothing") parent_plug["deadline"]["submitSuspended"] = Gaffer.BoolPlug(defaultValue=False) parent_plug["deadline"]["dependencyMode"] = Gaffer.StringPlug() parent_plug["deadline"]["dependencyMode"].setValue("Auto") parent_plug["deadline"]["auxFiles"] = Gaffer.StringVectorDataPlug(defaultValue=IECore.StringVectorData()) parent_plug["deadline"]["deadlineSettings"] = Gaffer.CompoundDataPlug() parent_plug["deadline"]["environmentVariables"] = Gaffer.CompoundDataPlug()
def testNoChildrenAccepted(self): p1 = Gaffer.BoolPlug() p2 = Gaffer.BoolPlug() self.assertFalse(p1.acceptsChild(p2)) self.assertRaises(RuntimeError, p1.addChild, p2)
def __init__( self, name = "LoggingTaskNode", log = None ) : GafferDispatch.TaskNode.__init__( self, name ) self["noOp"] = Gaffer.BoolPlug() self["requiresSequenceExecution"] = Gaffer.BoolPlug() self.log = log if log is not None else []
def __init__( self, name = "LocalDispatcher", jobPool = None ) : GafferDispatch.Dispatcher.__init__( self, name ) self["executeInBackground"] = Gaffer.BoolPlug( defaultValue = False ) self["ignoreScriptLoadErrors"] = Gaffer.BoolPlug( defaultValue = False ) self["environmentCommand"] = Gaffer.StringPlug() self.__jobPool = jobPool if jobPool else LocalDispatcher.defaultJobPool()
def testBoolDefaultValueHash(self): p1 = Gaffer.BoolPlug("p", Gaffer.Plug.Direction.In, True) p2 = Gaffer.BoolPlug("p", Gaffer.Plug.Direction.In, False) p3 = Gaffer.BoolPlug("p", Gaffer.Plug.Direction.In, False) self.assertNotEqual(p1.hash(), p2.hash()) self.assertEqual(p2.hash(), p3.hash())
def __init__(self, name="LocalDispatcher", jobPool=None): GafferDispatch.Dispatcher.__init__(self, name) backgroundPlug = Gaffer.BoolPlug("executeInBackground", defaultValue=False) self.addChild(backgroundPlug) self.addChild( Gaffer.BoolPlug("ignoreScriptLoadErrors", defaultValue=False)) self.__jobPool = jobPool if jobPool else LocalDispatcher.defaultJobPool( )
def testIndexInputAcceptance(self): cs = Gaffer.Switch() a = GafferTest.AddNode() a["boolInput"] = Gaffer.BoolPlug() a["boolOutput"] = Gaffer.BoolPlug(direction=Gaffer.Plug.Direction.Out) self.assertTrue(cs["index"].acceptsInput(a["op1"])) self.assertTrue(cs["index"].acceptsInput(a["sum"])) self.assertTrue(cs["enabled"].acceptsInput(a["boolInput"])) self.assertTrue(cs["enabled"].acceptsInput(a["boolOutput"]))
def testBoolPlugs( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["i"] = Gaffer.BoolPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["n"]["user"]["o"] = Gaffer.BoolPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["e"] = Gaffer.Expression() s["e"].setExpression( "parent.n.user.o = !parent.n.user.i;", "OSL" ) s["n"]["user"]["i"].setValue( True ) self.assertEqual( s["n"]["user"]["o"].getValue(), False ) s["n"]["user"]["i"].setValue( False ) self.assertEqual( s["n"]["user"]["o"].getValue(), True )
def testCanAnimate(self): s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["i"] = Gaffer.IntPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["b"] = Gaffer.BoolPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["n"]["user"]["s"] = Gaffer.StringPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) self.assertTrue(Gaffer.Animation.canAnimate(s["n"]["user"]["f"])) self.assertTrue(Gaffer.Animation.canAnimate(s["n"]["user"]["i"])) self.assertTrue(Gaffer.Animation.canAnimate(s["n"]["user"]["b"])) self.assertFalse(Gaffer.Animation.canAnimate(s["n"]["user"]["s"])) # Can't key because it has an input. s["n"]["user"]["f"].setInput(s["n"]["user"]["i"]) self.assertFalse(Gaffer.Animation.canAnimate(s["n"]["user"]["f"])) # Can't key because there's no parent where we can # put the Animation node. n = Gaffer.Node() n["user"]["f"] = Gaffer.FloatPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) self.assertFalse(Gaffer.Animation.canAnimate(n["user"]["f"]))
def __init__(self, name="PythonCommand"): GafferDispatch.ExecutableNode.__init__(self, name) self["command"] = Gaffer.StringPlug() self["variables"] = Gaffer.CompoundDataPlug() self["sequence"] = Gaffer.BoolPlug()
def __init__(self, applicationRoot): # \todo I wonder if it would make sense for this sort # of "bolt on" component to be a GraphComponent that was # parented under the ApplicationRoot somewhere, instead # of manually tracking the "parent" like this? self.__applicationRoot = weakref.ref(applicationRoot) self.__settings = Gaffer.Plug() self.__settings["enabled"] = Gaffer.BoolPlug(defaultValue=True) self.__settings["frequency"] = Gaffer.IntPlug(defaultValue=5, minValue=0) self.__settings["fileName"] = Gaffer.StringPlug( defaultValue= "${script:directory}/.gafferBackups/${script:name}-backup${backup:number}.gfr" ) self.__settings["files"] = Gaffer.IntPlug(defaultValue=10, minValue=1) applicationRoot["preferences"]["backups"] = self.__settings applicationRoot["preferences"].plugSetSignal().connect(self.__plugSet, scoped=False) self.__timer = QtCore.QTimer() self.__timer.timeout.connect(Gaffer.WeakMethod(self.__timeout)) # Initialise the timer self.__plugSet(self.__settings["enabled"])
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))
def __createXRayShader(): # ideally this could be any type of node (eg Box), but # SceneView seems to require a SceneProcessor. xray = GafferScene.SceneProcessor("XRay") xray["attributes"] = GafferScene.CustomAttributes() xray["attributes"]["attributes"].addChild( Gaffer.NameValuePlug("gl:depthTest", Gaffer.BoolPlug("value", defaultValue=False), True, "depthTest")) xray["attributes"]["in"].setInput(xray["in"]) xray["assignment"] = GafferScene.ShaderAssignment() xray["assignment"]["in"].setInput(xray["attributes"]["out"]) xray["shader"] = GafferScene.OpenGLShader("XRay") xray["shader"]["name"].setValue("xray") xray["shader"]["type"].setValue("gl:surface") xray["shader"]["parameters"].addChild( Gaffer.StringPlug("glFragmentSource", defaultValue=inspect.cleandoc(''' in vec3 fragmentN; in vec3 fragmentI; void main() { float f = abs( dot( normalize( fragmentI ), normalize( fragmentN ) ) ); gl_FragColor = vec4( mix( vec3( 0.7 ), vec3( 0.5 ), f ), 0.5 ); } '''))) xray["shader"]["out"] = Gaffer.Plug() xray["assignment"]["shader"].setInput(xray["shader"]["out"]) xray["out"].setInput(xray["assignment"]["out"]) return xray
def _doSetupPlugs(parentPlug): parentPlug["local"] = Gaffer.Plug() foregroundPlug = Gaffer.BoolPlug("executeInForeground", defaultValue=False) parentPlug["local"].addChild(foregroundPlug)
def testRunTimeTyped( self ) : p = Gaffer.BoolPlug( "b" ) self.assertEqual( p.typeName(), "Gaffer::BoolPlug" ) self.assertEqual( IECore.RunTimeTyped.typeNameFromTypeId( p.typeId() ), "Gaffer::BoolPlug" ) self.assertEqual( IECore.RunTimeTyped.baseTypeId( p.typeId() ), Gaffer.ValuePlug.staticTypeId() )
def __init__(self, name="LocalDispatcher"): Gaffer.Dispatcher.__init__(self, name) backgroundPlug = Gaffer.BoolPlug("executeInBackground", defaultValue=False) self.addChild(backgroundPlug)
def testDefaultExpressionForSupportedPlugs( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"].addChild( Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.FloatPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.StringPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.BoolPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V2fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V3iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Color3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Color4fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box2fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Box3iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.IntVectorDataPlug( defaultValue = IECore.IntVectorData( [ 0, 1 ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.FloatVectorDataPlug( defaultValue = IECore.FloatVectorData( [ 0, 1 ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.StringVectorDataPlug( defaultValue = IECore.StringVectorData( [ "a", "b" ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V3fVectorDataPlug( defaultValue = IECore.V3fVectorData( [ IECore.V3f( 1 ) ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.Color3fVectorDataPlug( defaultValue = IECore.Color3fVectorData( [ IECore.Color3f( 1 ) ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.M44fVectorDataPlug( defaultValue = IECore.M44fVectorData( [ IECore.M44f() ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["n"]["user"].addChild( Gaffer.V2iVectorDataPlug( defaultValue = IECore.V2iVectorData( [ IECore.V2i() ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s["e"] = Gaffer.Expression() for plug in s["n"]["user"] : value = plug.getValue() s["e"].setExpression( s["e"].defaultExpression( plug, "python" ) ) self.assertTrue( plug.getInput().node().isSame( s["e"] ) ) self.assertEqual( plug.getValue(), value )
def getItem(self, key): if key == "__contextCompatibility": # Plug no longer exists - just return a throwaway one to # keep old serialisations happy. return Gaffer.BoolPlug(key) return originalGetItem(self, key)
def __init__( self, name = "SystemCommand" ) : GafferDispatch.TaskNode.__init__( self, name ) self["command"] = Gaffer.StringPlug() self["shell"] = Gaffer.BoolPlug( defaultValue = True ) self["substitutions"] = Gaffer.CompoundDataPlug() self["environmentVariables"] = Gaffer.CompoundDataPlug()
def __promoteToBoxEnabledPlug( box, plug ) : with Gaffer.UndoContext( box.ancestor( Gaffer.ScriptNode ) ) : enabledPlug = box.getChild( "enabled" ) if enabledPlug is None : enabledPlug = Gaffer.BoolPlug( "enabled", defaultValue = True, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) box["enabled"] = enabledPlug plug.setInput( enabledPlug )
def __init__(self, name="HierarchyTask"): super(HierarchyTask, self).__init__(name) Gaffer.Metadata.registerValue(self.__class__, "nodeGadget:color", _HIERARCHY_TASK_COLOR) Gaffer.Metadata.registerValue(self.__class__, "icon", "hierarchy.png") title_plug = Gaffer.StringPlug("title", Gaffer.Plug.Direction.In, defaultValue="No title set.") Gaffer.Metadata.registerPlugValue(title_plug, "nodule:type", "") self.addChild(title_plug) description_plug = Gaffer.StringPlug("description", Gaffer.Plug.Direction.In, defaultValue="No description") Gaffer.Metadata.registerPlugValue(description_plug, "plugValueWidget:type", "GafferUI.MultiLineStringPlugValueWidget") Gaffer.Metadata.registerPlugValue(description_plug, "multiLineStringPlugValueWidget:continuousUpdate", True) Gaffer.Metadata.registerPlugValue(description_plug, "nodule:type", "") self.addChild(description_plug) argument_defaults_plug = Gaffer.CompoundDataPlug("argument_defaults", Gaffer.Plug.Direction.In) Gaffer.Metadata.registerPlugValue(argument_defaults_plug, "nodule:type", "") Gaffer.Metadata.registerValue( argument_defaults_plug, "layout:section", "Settings.Argument_Defaults" ) Gaffer.Metadata.registerValue( argument_defaults_plug, "layout:section:Settings.ArgumentDefaults:summary", "The default values for arguments the task requires." ) self.addChild(argument_defaults_plug) elements_id_plug = Gaffer.StringPlug("elements_id", Gaffer.Plug.Direction.In, defaultValue="") Gaffer.Metadata.registerPlugValue(elements_id_plug, "nodule:type", "") self.addChild(elements_id_plug) per_element_plug = Gaffer.BoolPlug("per_element", Gaffer.Plug.Direction.In, defaultValue=False) Gaffer.Metadata.registerPlugValue(per_element_plug, "nodule:type", "") self.addChild(per_element_plug) in_plug = GafferDispatch.TaskNode.TaskPlug("in", Gaffer.Plug.Direction.In) Gaffer.Metadata.registerPlugValue(in_plug, "nodule:type", "GafferUI::StandardNodule") Gaffer.Metadata.registerPlugValue(in_plug, "nodule:color", _TASK_IN_OUT_COLOR) Gaffer.Metadata.registerPlugValue(in_plug, "noduleLayout:section", "top") Gaffer.Metadata.registerPlugValue(in_plug, "plugValueWidget:type", "") self.addChild(in_plug) out_plug = GafferDispatch.TaskNode.TaskPlug("out", Gaffer.Plug.Direction.Out) Gaffer.Metadata.registerPlugValue(out_plug, "nodule:type", "GafferUI::StandardNodule") Gaffer.Metadata.registerPlugValue(out_plug, "nodule:color", _TASK_IN_OUT_COLOR ) Gaffer.Metadata.registerPlugValue(out_plug, "noduleLayout:section", "bottom") Gaffer.Metadata.registerPlugValue(out_plug, "plugValueWidget:type", "") self.addChild(out_plug) processor_plug = ProcessorPlug("processor", Gaffer.Plug.Direction.In) Gaffer.Metadata.registerPlugValue(processor_plug, "nodule:type", "GafferUI::StandardNodule") Gaffer.Metadata.registerPlugValue(processor_plug, "nodule:color", _PROCESSOR_IN_OUT_COLOR) Gaffer.Metadata.registerPlugValue(processor_plug, "noduleLayout:section", "right") Gaffer.Metadata.registerPlugValue(processor_plug, "plugValueWidget:type", "") self.addChild(processor_plug)
def getItem(self, key): if key == "adjustBounds": # This plug no longer exists, but we provide a # surrogate just to keep old scripts loading without # error. return Gaffer.BoolPlug("adjustBoundsSurrogate") return originalGetItem(self, key)
def __init__(self, name="Jobtronaut"): super(JobtronautDispatcher, self).__init__(name) self.scriptnode = Gaffer.ScriptNode("ScriptNode") self.graphgadget = None # Set and hide existing plugs self.getChild("jobsDirectory").setValue("/tmp/gafferdispatch") Gaffer.Metadata.registerPlugValue(self.__class__, "framesMode", "plugValueWidget:type", "") Gaffer.Metadata.registerPlugValue(self.__class__, "ignoreScriptLoadErrors", "plugValueWidget:type", "") Gaffer.Metadata.registerPlugValue(self.__class__, "environmentCommand", "plugValueWidget:type", "") Gaffer.Metadata.registerPlugValue(self.__class__, "jobName", "plugValueWidget:type", "") Gaffer.Metadata.registerPlugValue(self.__class__, "jobsDirectory", "plugValueWidget:type", "") # Add custom plugs to the Dispatcher UI plugins_location_plug = Gaffer.StringPlug("PluginsFile", Gaffer.Plug.Direction.In) plugins_location_plug.setValue("/tmp/temptasks.py") Gaffer.Metadata.registerPlugValue(plugins_location_plug, "nodule:type", "") Gaffer.Metadata.registerPlugValue( plugins_location_plug, "plugValueWidget:type", "GafferUI.FileSystemPathPlugValueWidget") Gaffer.Metadata.registerPlugValue(plugins_location_plug, "path:leaf", False) self.addChild(plugins_location_plug) add_commandtasks_plug = Gaffer.BoolPlug("AddCommandtasks", Gaffer.Plug.Direction.In, defaultValue=True) Gaffer.Metadata.registerPlugValue(add_commandtasks_plug, "node:type", "") self.addChild(add_commandtasks_plug) add_processors_plug = Gaffer.BoolPlug("AddProcessors", Gaffer.Plug.Direction.In, defaultValue=True) Gaffer.Metadata.registerPlugValue(add_processors_plug, "node:type", "") self.addChild(add_processors_plug)
def __init__( self, name = "_Camera" ) : Gaffer.Node.__init__( self, name ) self["in"] = GafferScene.ScenePlug() self["addCamera"] = Gaffer.BoolPlug( defaultValue = False ) self["lookAt"] = Gaffer.StringPlug( defaultValue = "/" ) self["depth"] = Gaffer.FloatPlug( defaultValue = 20, minValue = 0 ) self["angle"] = Gaffer.FloatPlug() self["elevation"] = Gaffer.FloatPlug( defaultValue = 10, minValue = -90, maxValue = 90 ) self["camera"] = GafferScene.Camera() self["camera"]["name"].setValue( "previewCamera" ) self["parent"] = GafferScene.Parent() self["parent"]["in"].setInput( self["in"] ) self["parent"]["parent"].setValue( "/" ) self["parent"]["child"].setInput( self["camera"]["out"] ) self["cameraFilter"] = GafferScene.PathFilter() self["cameraFilter"]["paths"].setValue( IECore.StringVectorData( [ "/previewCamera" ] ) ) self["parentConstraint"] = GafferScene.ParentConstraint() self["parentConstraint"]["in"].setInput( self["parent"]["out"] ) self["parentConstraint"]["target"].setInput( self["lookAt"] ) self["parentConstraint"]["targetMode"].setValue( self["parentConstraint"].TargetMode.BoundCenter ) self["parentConstraint"]["filter"].setInput( self["cameraFilter"]["match"] ) self["cameraRotate"] = GafferScene.Transform() self["cameraRotate"]["in"].setInput( self["parentConstraint"]["out"] ) self["cameraRotate"]["transform"]["rotate"]["y"].setInput( self["angle"] ) self["cameraRotate"]["space"].setValue( self["cameraRotate"].Space.Object ) self["cameraRotate"]["filter"].setInput( self["cameraFilter"]["match"] ) self["elevationExpression"] = Gaffer.Expression() self["elevationExpression"]["engine"].setValue( "python" ) self["elevationExpression"]["expression"].setValue( 'parent["cameraRotate"]["transform"]["rotate"]["x"] = -parent["elevation"]' ) self["cameraTranslate"] = GafferScene.Transform() self["cameraTranslate"]["in"].setInput( self["cameraRotate"]["out"] ) self["cameraTranslate"]["transform"]["translate"]["z"].setInput( self["depth"] ) self["cameraTranslate"]["space"].setValue( self["cameraRotate"].Space.Object ) self["cameraTranslate"]["filter"].setInput( self["cameraFilter"]["match"] ) self["options"] = GafferScene.StandardOptions() self["options"]["options"]["renderCamera"]["enabled"].setValue( True ) self["options"]["options"]["renderCamera"]["value"].setValue( "/previewCamera" ) self["options"]["in"].setInput( self["cameraTranslate"]["out"] ) self["switch"] = GafferScene.SceneSwitch() self["switch"]["in"].setInput( self["in"] ) self["switch"]["in1"].setInput( self["options"]["out"] ) self["switch"]["index"].setInput( self["addCamera"] ) self["out"] = GafferScene.ScenePlug( direction = Gaffer.Plug.Direction.Out ) self["out"].setInput( self["switch"]["out"] )
def __init__( self, name = "PythonCommand" ) : GafferDispatch.TaskNode.__init__( self, name ) # Turn off automatic substitutions for the command, since it's a pain # to have to manually escape things, and the context is available # directly anyway. self["command"] = Gaffer.StringPlug( substitutions = Gaffer.Context.Substitutions.NoSubstitutions ) self["variables"] = Gaffer.CompoundDataPlug() self["sequence"] = Gaffer.BoolPlug()
def testCreateCounterpart(self): p1 = Gaffer.BoolPlug("p", Gaffer.Plug.Direction.In, True) p2 = p1.createCounterpart("a", Gaffer.Plug.Direction.Out) self.assertEqual(p2.getName(), "a") self.assertEqual(p2.direction(), Gaffer.Plug.Direction.Out) self.assertEqual(p2.defaultValue(), p1.defaultValue()) self.assertEqual(p2.getFlags(), p1.getFlags())
def __init__( self, name = "EnableAbleNode" ) : Gaffer.DependencyNode.__init__( self, name ) self.addChild( Gaffer.BoolPlug( "enabled", Gaffer.Plug.Direction.In, True ) ) self.addChild( Gaffer.IntPlug( "aIn" ) ) self.addChild( Gaffer.IntPlug( "bIn" ) ) self.addChild( Gaffer.IntPlug( "aOut", Gaffer.Plug.Direction.Out ) ) self.addChild( Gaffer.IntPlug( "bOut", Gaffer.Plug.Direction.Out ) ) self.addChild( Gaffer.IntPlug( "cOut", Gaffer.Plug.Direction.Out ) )
def __init__( self, name="CompoundOut" ) : Gaffer.DependencyNode.__init__( self, name ) self["in"] = Gaffer.IntPlug() self["out"] = Gaffer.Plug( direction = Gaffer.Plug.Direction.Out ) self["out"]["one"] = Gaffer.IntPlug( direction = Gaffer.Plug.Direction.Out ) self["out"]["two"] = Gaffer.IntPlug( direction = Gaffer.Plug.Direction.Out ) self["behaveBadly"] = Gaffer.BoolPlug( defaultValue = False )