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 )
