def testNestedEditScopes( self ) : outerScope = Gaffer.EditScope() outerScope.setup( GafferScene.ScenePlug() ) innerScope = Gaffer.EditScope() outerScope["Inner"] = innerScope innerScope.setup( outerScope["BoxIn"]["out"] ) innerScope["in"].setInput( outerScope["BoxIn"]["out"] ) innerScope["parent"] = GafferScene.Parent() innerScope["parent"]["parent"].setValue( "/" ) innerScope["parent"]["in"].setInput( innerScope["BoxIn"]["out"] ) innerScope["BoxOut"]["in"].setInput( innerScope["parent"]["out"] ) innerScope["plane"] = GafferScene.Plane() innerScope["parent"]["children"][0].setInput( innerScope["plane"]["out"] ) outerScope["BoxOut"]["in"].setInput( innerScope["out"] ) selection = GafferSceneUI.TransformTool.Selection( outerScope["out"], "/plane", Gaffer.Context(), innerScope ) self.assertTrue( selection.editable() ) self.assertEqual( selection.editTarget(), innerScope["plane"]["transform"] ) self.assertEqual( selection.editScope(), innerScope ) selection = GafferSceneUI.TransformTool.Selection( outerScope["out"], "/plane", Gaffer.Context(), outerScope ) self.assertTrue( selection.editable() ) self.assertEqual( selection.editTarget(), outerScope ) self.assertEqual( selection.editScope(), outerScope )
def testParameterEditReadOnlyReason( self ) : s = Gaffer.ScriptNode() s["light"] = GafferSceneTest.TestLight() s["scope"] = Gaffer.EditScope() s["scope"].setup( s["light"]["out"] ) s["scope"]["in"].setInput( s["light"]["out"] ) s["box"] = Gaffer.Box.create( s, Gaffer.StandardSet( [ s["light"], s["scope"] ] ) ) self.assertIsNone( GafferScene.EditScopeAlgo.parameterEditReadOnlyReason( s["box"]["scope"], "/light", "light", ( "", "intensity" ) ) ) for component in ( s["box"], s["box"]["scope"] ): Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.parameterEditReadOnlyReason( s["box"]["scope"], "/light", "light", ( "", "intensity" ) ), s["box"] ) Gaffer.MetadataAlgo.setReadOnly( s["box"], False ) self.assertEqual( GafferScene.EditScopeAlgo.parameterEditReadOnlyReason( s["box"]["scope"], "/light", "light", ( "", "intensity" ) ), s["box"]["scope"] ) Gaffer.MetadataAlgo.setReadOnly( s["box"]["scope"], False ) GafferScene.EditScopeAlgo.acquireParameterEdit( s["box"]["scope"], "/light", "light", ( "", "intensity" ) ) self.assertIsNone( GafferScene.EditScopeAlgo.parameterEditReadOnlyReason( s["box"]["scope"], "/light", "light", ( "", "intensity" ) ) ) candidateComponents = ( s["box"]["scope"]["LightEdits"]["edits"][1]["cells"]["intensity"]["value"]["value"][1], s["box"]["scope"]["LightEdits"]["edits"][1]["cells"]["intensity"]["value"]["mode"], s["box"]["scope"]["LightEdits"]["edits"][1]["cells"]["intensity"]["value"]["enabled"], s["box"]["scope"]["LightEdits"]["edits"][1]["cells"]["intensity"]["value"]["name"], s["box"]["scope"]["LightEdits"]["edits"][1]["cells"]["intensity"]["value"], s["box"]["scope"]["LightEdits"]["edits"][1]["cells"]["intensity"], s["box"]["scope"]["LightEdits"]["edits"][1]["cells"], s["box"]["scope"]["LightEdits"]["edits"][1], s["box"]["scope"]["LightEdits"]["edits"], s["box"]["scope"]["LightEdits"], s["box"]["scope"], s["box"] ) for component in candidateComponents : Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.parameterEditReadOnlyReason( s["box"]["scope"], "/light", "light", ( "", "intensity" ) ), component ) for component in candidateComponents : Gaffer.MetadataAlgo.setReadOnly( component, False ) # We can't remove parameter edits, they're just disabled (as the row is shared with other parameters), # so we try to create one for another light instead s["box"]["light"]["name"].setValue( "light2" ) self.assertIsNone( GafferScene.EditScopeAlgo.acquireParameterEdit( s["box"]["scope"], "/light2", "light", ( "", "intensity" ), createIfNecessary = False ) ) for component in ( s["box"]["scope"]["LightEdits"]["edits"], s["box"]["scope"]["LightEdits"] ) : Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.parameterEditReadOnlyReason( s["box"]["scope"], "/light2", "light", ( "", "intensity" ) ), component )
def testParameterEditsDontAffectOtherAttributes( self ) : light = GafferSceneTest.TestLight() lightFilter = GafferScene.PathFilter() lightFilter["paths"].setValue( IECore.StringVectorData( [ "/light" ] ) ) shuffleAttributes = GafferScene.ShuffleAttributes() shuffleAttributes["in"].setInput( light["out"] ) shuffleAttributes["filter"].setInput( lightFilter["out"] ) editScope = Gaffer.EditScope() editScope.setup( shuffleAttributes["out"] ) editScope["in"].setInput( shuffleAttributes["out"] ) # Make an edit for the "light" attribute. edit = GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "light", ( "", "intensity" ) ) edit["enabled"].setValue( True ) edit["value"].setValue( imath.Color3f( 1, 2, 3 ) ) self.assertEqual( editScope["out"].attributes( "/light" )["light"].outputShader().parameters["intensity"].value, imath.Color3f( 1, 2, 3 ) ) # Shuffle the light shader to another attribute. It should not be affected # by the edit. shuffleAttributes["shuffles"].addChild( Gaffer.ShufflePlug( "light", "test:light" ) ) self.assertEqual( editScope["out"].attributes( "/light" )["test:light"].outputShader().parameters["intensity"].value, imath.Color3f( 0 ) )
def testProcessorNames( self ) : plane = GafferScene.Plane() planeFilter = GafferScene.PathFilter() planeFilter["paths"].setValue( IECore.StringVectorData( [ "/plane" ]) ) shader = GafferSceneTest.TestShader() shaderAssignment = GafferScene.ShaderAssignment() shaderAssignment["in"].setInput( plane["out"] ) shaderAssignment["filter"].setInput( planeFilter["out"] ) shaderAssignment["shader"].setInput( shader["out"] ) editScope = Gaffer.EditScope() editScope.setup( shaderAssignment["out"] ) editScope["in"].setInput( shaderAssignment["out"] ) for attributeName, processorName in [ ( "gl:surface", "OpenGLSurfaceEdits" ), ( "gl:light", "OpenGLLightEdits" ), ( "surface", "SurfaceEdits" ), ( "displacement", "DisplacementEdits" ), ( "test:lightFilter:one", "TestLightFilterOneEdits" ), ( "test:lightFilter:bigGobo", "TestLightFilterBigGoboEdits" ), ] : shader["type"].setValue( attributeName ) edit = GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/plane", attributeName, ( "", "i" ) ) self.assertEqual( edit.node().getName(), processorName )
def testTransform( self ) : plane = GafferScene.Plane() plane["transform"]["translate"].setValue( imath.V3f( 1, 0, 0 ) ) editScope = Gaffer.EditScope() editScope.setup( plane["out"] ) editScope["in"].setInput( plane["out"] ) self.assertFalse( GafferScene.EditScopeAlgo.hasTransformEdit( editScope, "/plane" ) ) self.assertIsNone( GafferScene.EditScopeAlgo.acquireTransformEdit( editScope, "/plane", createIfNecessary = False ) ) self.assertEqual( len( list( GafferScene.SceneProcessor.Range( editScope ) ) ), 0 ) self.assertEqual( editScope["out"].transform( "/plane" ), plane["transform"].matrix() ) edit = GafferScene.EditScopeAlgo.acquireTransformEdit( editScope, "/plane" ) self.assertIsInstance( edit, GafferScene.EditScopeAlgo.TransformEdit ) self.assertTrue( GafferScene.EditScopeAlgo.hasTransformEdit( editScope, "/plane" ) ) self.assertIsNotNone( GafferScene.EditScopeAlgo.acquireTransformEdit( editScope, "/plane", createIfNecessary = False ) ) self.assertEqual( editScope["out"].transform( "/plane" ), imath.M44f() ) edit.translate.setValue( imath.V3f( 2, 3, 4 ) ) self.assertEqual( editScope["out"].transform( "/plane" ), imath.M44f().translate( imath.V3f( 2, 3, 4 ) ) ) GafferScene.EditScopeAlgo.removeTransformEdit( editScope, "/plane" ) self.assertFalse( GafferScene.EditScopeAlgo.hasTransformEdit( editScope, "/plane" ) ) self.assertIsNone( GafferScene.EditScopeAlgo.acquireTransformEdit( editScope, "/plane", createIfNecessary = False ) ) self.assertEqual( editScope["out"].transform( "/plane" ), plane["transform"].matrix() )
def testPruneReadOnlyReason( self ) : s = Gaffer.ScriptNode() s["cube"] = GafferScene.Cube() s["scope"] = Gaffer.EditScope() s["scope"].setup( s["cube"]["out"] ) s["scope"]["in"].setInput( s["cube"]["out"] ) s["box"] = Gaffer.Box.create( s, Gaffer.StandardSet( [ s["cube"], s["scope"] ] ) ) self.assertIsNone( GafferScene.EditScopeAlgo.prunedReadOnlyReason( s["box"]["scope"] ) ) for component in ( s["box"], s["box"]["scope"] ): Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.prunedReadOnlyReason( s["box"]["scope"] ), s["box"] ) Gaffer.MetadataAlgo.setReadOnly( s["box"], False ) self.assertEqual( GafferScene.EditScopeAlgo.prunedReadOnlyReason( s["box"]["scope"] ), s["box"]["scope"] ) Gaffer.MetadataAlgo.setReadOnly( s["box"]["scope"], False ) GafferScene.EditScopeAlgo.setPruned( s["box"]["scope"], "/cube", True ) self.assertIsNone( GafferScene.EditScopeAlgo.prunedReadOnlyReason( s["box"]["scope"] ) ) for component in ( s["box"]["scope"]["PruningEdits"]["paths"], s["box"]["scope"]["PruningEdits"], s["box"]["scope"], s["box"] ) : Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.prunedReadOnlyReason( s["box"]["scope"] ), component )
def testEditScopes( self ) : script = Gaffer.ScriptNode() script["sphere"] = GafferScene.Sphere() script["sphere"]["transform"]["translate"].setValue( imath.V3f( 1, 0, 0 ) ) script["editScope"] = Gaffer.EditScope() script["editScope"].setup( script["sphere"]["out"] ) script["editScope"]["in"].setInput( script["sphere"]["out"] ) view = GafferSceneUI.SceneView() view["in"].setInput( script["editScope"]["out"] ) view["editScope"].setInput( script["editScope"]["out"] ) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher( [ "/sphere" ] ) ) tool = GafferSceneUI.TranslateTool( view ) tool["active"].setValue( True ) self.assertEqual( tool.handlesTransform(), imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) self.assertEqual( len( tool.selection() ), 1 ) self.assertTrue( tool.selection()[0].editable() ) self.assertFalse( GafferScene.EditScopeAlgo.hasTransformEdit( script["editScope"], "/sphere" ) ) self.assertEqual( script["editScope"]["out"].transform( "/sphere" ), imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) tool.translate( imath.V3f( 0, 1, 0 ) ) self.assertEqual( tool.handlesTransform(), imath.M44f().translate( imath.V3f( 1, 1, 0 ) ) ) self.assertEqual( len( tool.selection() ), 1 ) self.assertTrue( tool.selection()[0].editable() ) self.assertTrue( GafferScene.EditScopeAlgo.hasTransformEdit( script["editScope"], "/sphere" ) ) self.assertEqual( script["editScope"]["out"].transform( "/sphere" ), imath.M44f().translate( imath.V3f( 1, 1, 0 ) ) )
def testParameterEditLocalisation( self ) : sphere = GafferScene.Sphere() group = GafferScene.Group() group["in"][0].setInput( sphere["out"] ) groupFilter = GafferScene.PathFilter() groupFilter["paths"].setValue( IECore.StringVectorData( [ "/group" ] ) ) shader = GafferSceneTest.TestShader() shader["type"].setValue( "test:surface" ) shaderAssignment = GafferScene.ShaderAssignment() shaderAssignment["in"].setInput( group["out"] ) shaderAssignment["filter"].setInput( groupFilter["out"] ) shaderAssignment["shader"].setInput( shader["out"] ) editScope = Gaffer.EditScope() editScope.setup( shaderAssignment["out"] ) editScope["in"].setInput( shaderAssignment["out"] ) self.assertIn( "test:surface", editScope["out"].attributes( "/group" ) ) self.assertNotIn( "test:surface", editScope["out"].attributes( "/group/sphere" ) ) edit = GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/group/sphere", "test:surface", ( "", "i" ) ) edit["enabled"].setValue( True ) edit["value"].setValue( 10 ) self.assertEqual( editScope["out"].attributes( "/group" ), editScope["in"].attributes( "/group" ) ) self.assertIn( "test:surface", editScope["out"].attributes( "/group/sphere" ) ) self.assertEqual( editScope["out"].attributes( "/group/sphere" )["test:surface"].outputShader().parameters["i"].value, 10 )
def testTransformEditReadOnlyReason( self ) : s = Gaffer.ScriptNode() s["cube"] = GafferScene.Cube() s["scope"] = Gaffer.EditScope() s["scope"].setup( s["cube"]["out"] ) s["scope"]["in"].setInput( s["cube"]["out"] ) s["box"] = Gaffer.Box.create( s, Gaffer.StandardSet( [ s["cube"], s["scope"] ] ) ) self.assertIsNone( GafferScene.EditScopeAlgo.transformEditReadOnlyReason( s["box"]["scope"], "/cube" ) ) for component in ( s["box"], s["box"]["scope"] ): Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.transformEditReadOnlyReason( s["box"]["scope"], "/cube" ), s["box"] ) Gaffer.MetadataAlgo.setReadOnly( s["box"], False ) self.assertEqual( GafferScene.EditScopeAlgo.transformEditReadOnlyReason( s["box"]["scope"], "/cube" ), s["box"]["scope"] ) Gaffer.MetadataAlgo.setReadOnly( s["box"]["scope"], False ) GafferScene.EditScopeAlgo.acquireTransformEdit( s["box"]["scope"], "/cube" ) self.assertIsNone( GafferScene.EditScopeAlgo.transformEditReadOnlyReason( s["box"]["scope"], "/cube" ) ) candidateComponents = ( s["box"]["scope"]["TransformEdits"]["edits"][1]["cells"]["pivot"][1], s["box"]["scope"]["TransformEdits"]["edits"][1]["cells"]["pivot"], s["box"]["scope"]["TransformEdits"]["edits"][1]["cells"]["scale"], s["box"]["scope"]["TransformEdits"]["edits"][1]["cells"]["rotate"], s["box"]["scope"]["TransformEdits"]["edits"][1]["cells"]["translate"], s["box"]["scope"]["TransformEdits"]["edits"][1]["cells"], s["box"]["scope"]["TransformEdits"]["edits"][1], s["box"]["scope"]["TransformEdits"]["edits"], s["box"]["scope"]["TransformEdits"], s["box"]["scope"], s["box"] ) for component in candidateComponents : Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.transformEditReadOnlyReason( s["box"]["scope"], "/cube" ), component ) for component in candidateComponents : Gaffer.MetadataAlgo.setReadOnly( component, False ) GafferScene.EditScopeAlgo.removeTransformEdit( s["box"]["scope"], "/cube" ) self.assertIsNone( GafferScene.EditScopeAlgo.acquireTransformEdit( s["box"]["scope"], "/cube", createIfNecessary = False ) ) for component in ( s["box"]["scope"]["TransformEdits"]["edits"], s["box"]["scope"]["TransformEdits"] ) : Gaffer.MetadataAlgo.setReadOnly( component, True ) self.assertEqual( GafferScene.EditScopeAlgo.transformEditReadOnlyReason( s["box"]["scope"], "/cube" ), component )
def testEditScope( self ) : view = self.MyView() addNode = GafferTest.AddNode() editScope = Gaffer.EditScope() editScope.setup( view["in"] ) self.assertEqual( view.editScope(), None ) view["editScope"].setInput( editScope["out"] ) self.assertEqual( view.editScope(), editScope )
def testAcquireTransformEdit( self ) : plane = GafferScene.Plane() selection = GafferSceneUI.TransformTool.Selection( plane["out"], "/plane", Gaffer.Context(), None ) edit = selection.acquireTransformEdit() self.assertEqual( edit.translate, plane["transform"]["translate"] ) self.assertEqual( edit.rotate, plane["transform"]["rotate"] ) self.assertEqual( edit.scale, plane["transform"]["scale"] ) self.assertEqual( edit.pivot, plane["transform"]["pivot"] ) editScope = Gaffer.EditScope() editScope.setup( plane["out"] ) editScope["in"].setInput( plane["out"] ) selection = GafferSceneUI.TransformTool.Selection( editScope["out"], "/plane", Gaffer.Context(), editScope ) self.assertIsNone( selection.acquireTransformEdit( createIfNecessary = False ) ) edit = selection.acquireTransformEdit() self.assertTrue( editScope.isAncestorOf( edit.translate ) ) # Check readOnly is respected plane["name"].setValue( "plane2" ) Gaffer.MetadataAlgo.setReadOnly( plane["transform"]["translate"], True ) # We still allow 'editing' of existing plugs, but the handles should take care of disabling themselves. selection = GafferSceneUI.TransformTool.Selection( plane["out"], "/plane2", Gaffer.Context(), None ) self.assertTrue( selection.editable() ) self.assertEqual( selection.warning(), "\"Plane.transform.translate\" is locked" ) Gaffer.MetadataAlgo.setReadOnly( editScope, True ) selection = GafferSceneUI.TransformTool.Selection( editScope["out"], "/plane2", Gaffer.Context(), editScope ) self.assertFalse( selection.editable() ) self.assertEqual( selection.warning(), "\"EditScope\" is locked" ) with six.assertRaisesRegex( self, RuntimeError, "Selection is not editable" ) : self.assertIsNone( selection.acquireTransformEdit() ) Gaffer.MetadataAlgo.setReadOnly( editScope, False ) selection = GafferSceneUI.TransformTool.Selection( editScope["out"], "/plane2", Gaffer.Context(), editScope ) edit = selection.acquireTransformEdit() Gaffer.MetadataAlgo.setReadOnly( edit.translate.ancestor( Gaffer.Spreadsheet.RowsPlug ).source(), True ) plane["name"].setValue( "plane3" ) selection = GafferSceneUI.TransformTool.Selection( editScope["out"], "/plane3", Gaffer.Context(), editScope ) self.assertFalse( selection.editable() ) self.assertEqual( selection.warning(), "\"EditScope.TransformEdits.edits\" is locked" ) with six.assertRaisesRegex( self, RuntimeError, "Selection is not editable" ) : self.assertIsNone( selection.acquireTransformEdit() )
def testProcessors(self):
e = Gaffer.EditScope()
e.setup(Gaffer.IntPlug())
self.assertEqual(e.processors(), [])
p = e.acquireProcessor("Test")
self.assertEqual(e.processors(), [p])
# Remove processor from the main stream but keep it in the
# EditScope. It should no longer be returned by `processors()`.
p["out"].outputs()[0].setInput(p["in"].getInput())
self.assertEqual(e.processors(), [])
def testEditScopeNesting(self):
light = GafferSceneTest.TestLight()
editScope1 = Gaffer.EditScope("EditScope1")
editScope1.setup(light["out"])
editScope1["in"].setInput(light["out"])
def inspector(scene, path, parameter, editScope, attribute="light"):
history = GafferScene.SceneAlgo.history(scene["attributes"], path)
attributeHistory = GafferScene.SceneAlgo.attributeHistory(
history, attribute)
return GafferSceneUI.SceneViewUI._ParameterInspector(
attributeHistory, parameter, editScope)
i = inspector(editScope1["out"], "/light", "intensity", editScope1)
scope1Edit = i.acquireEdit()
scope1Edit["enabled"].setValue(True)
self.assertEqual(scope1Edit.ancestor(Gaffer.EditScope), editScope1)
editScope2 = Gaffer.EditScope("EditScope2")
editScope2.setup(light["out"])
editScope1.addChild(editScope2)
editScope2["in"].setInput(
scope1Edit.ancestor(GafferScene.SceneProcessor)["out"])
editScope1["BoxOut"]["in"].setInput(editScope2["out"])
i = inspector(editScope1["out"], "/light", "intensity", editScope2)
scope2Edit = i.acquireEdit()
scope2Edit["enabled"].setValue(True)
self.assertEqual(scope2Edit.ancestor(Gaffer.EditScope), editScope2)
# Check we still find the edit in scope 1
i = inspector(editScope1["out"], "/light", "intensity", editScope1)
self.assertEqual(i.acquireEdit().ancestor(Gaffer.EditScope),
editScope1)
def testParentAndChildInSameEditScope( self ) : script = Gaffer.ScriptNode() script["cube"] = GafferScene.Cube() script["cube"]["transform"]["translate"].setValue( imath.V3f( 0, 1, 0 ) ) script["group"] = GafferScene.Group() script["group"]["in"][0].setInput( script["cube"]["out"] ) script["editScope"] = Gaffer.EditScope() script["editScope"].setup( script["group"]["out"] ) script["editScope"]["in"].setInput( script["group"]["out"] ) view = GafferSceneUI.SceneView() view["in"].setInput( script["editScope"]["out"] ) view["editScope"].setInput( script["editScope"]["out"] ) groupTransformEdit = GafferScene.EditScopeAlgo.acquireTransformEdit( script["editScope"], "/group" ) groupTransformEdit.rotate["y"].setValue( 90 ) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher( [ "/group/cube" ] ) ) tool = GafferSceneUI.TranslateTool( view ) tool["active"].setValue( True ) self.assertTrue( tool.handlesTransform().equalWithAbsError( groupTransformEdit.matrix() * imath.M44f().translate( imath.V3f( 0, 1, 0 ) ), 0.00001 ) ) tool.translate( imath.V3f( 1, 0, 0 ) ) self.assertTrue( script["editScope"]["out"].fullTransform( "/group/cube" ).equalWithAbsError( imath.M44f().translate( imath.V3f( 1, 1, 0 ) ) * groupTransformEdit.matrix(), 0.00001 ) ) tool.translate( imath.V3f( 1, 0, 0 ) ) self.assertTrue( script["editScope"]["out"].fullTransform( "/group/cube" ).equalWithAbsError( imath.M44f().translate( imath.V3f( 2, 1, 0 ) ) * groupTransformEdit.matrix(), 0.00001 ) )
def testTransformProcessorNotCreatedPrematurely( self ) : plane = GafferScene.Plane() plane["transform"]["translate"].setValue( imath.V3f( 1, 0, 0 ) ) editScope = Gaffer.EditScope() editScope.setup( plane["out"] ) editScope["in"].setInput( plane["out"] ) self.assertFalse( "TransformEdits" in editScope ) GafferScene.EditScopeAlgo.acquireTransformEdit( editScope, "/plane", createIfNecessary = False ) self.assertFalse( "TransformEdits" in editScope ) GafferScene.EditScopeAlgo.acquireTransformEdit( editScope, "/plane" ) self.assertTrue( "TransformEdits" in editScope )
def testEditScopes(self):
script = Gaffer.ScriptNode()
script["camera"] = GafferScene.Camera()
script["editScope"] = Gaffer.EditScope()
script["editScope"].setup(script["camera"]["out"])
script["editScope"]["in"].setInput(script["camera"]["out"])
view = GafferSceneUI.SceneView()
view["in"].setInput(script["editScope"]["out"])
view["camera"]["lookThroughEnabled"].setValue(True)
view["camera"]["lookThroughCamera"].setValue("/camera")
tool = GafferSceneUI.CameraTool(view)
tool["active"].setValue(True)
script["camera"]["transform"]["translate"].setValue(imath.V3f(1, 2, 3))
script["camera"]["transform"]["rotate"].setValue(imath.V3f(1, 2, 3))
# Without EditScope, should edit Camera node directly.
cameraTransform = imath.M44f().translate(imath.V3f(10, 5, 1)).rotate(
imath.V3f(math.pi / 4))
view.viewportGadget().setCameraTransform(cameraTransform)
self.assertFalse(
GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"],
"/camera"))
self.assertTrue(
script["camera"]["out"].transform("/camera").equalWithAbsError(
cameraTransform, 0.00001), )
# With EditScope
view["editScope"].setInput(script["editScope"]["out"])
cameraTransform.translate(imath.V3f(1, 2, 3))
view.viewportGadget().setCameraTransform(cameraTransform)
self.assertTrue(
GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"],
"/camera"))
self.assertTrue(
script["editScope"]["out"].transform("/camera").equalWithAbsError(
cameraTransform, 0.00001), )
self.assertTrue(
GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"],
"/camera"))
def testPruningSerialisation( self ) : s = Gaffer.ScriptNode() s["plane"] = GafferScene.Plane() s["editScope"] = Gaffer.EditScope() s["editScope"].setup( s["plane"]["out"] ) GafferScene.EditScopeAlgo.setPruned( s["editScope"], "/plane", True ) self.assertTrue( GafferScene.EditScopeAlgo.getPruned( s["editScope"], "/plane" ), True ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) self.assertTrue( GafferScene.EditScopeAlgo.getPruned( s2["editScope"], "/plane" ), True )
def testSetup(self):
e = Gaffer.EditScope()
self.assertNotIn("in", e)
self.assertNotIn("out", e)
e.setup(Gaffer.IntPlug())
self.assertIn("in", e)
self.assertIn("out", e)
self.assertIsInstance(e["in"], Gaffer.IntPlug)
self.assertIsInstance(e["out"], Gaffer.IntPlug)
self.assertEqual(e["out"].source(), e["in"])
self.assertEqual(e.correspondingInput(e["out"]), e["in"])
def testBrokenInternalConnection(self):
e = Gaffer.EditScope()
e.setup(Gaffer.IntPlug())
p = e.acquireProcessor("Test")
self.assertEqual(e.processors(), [p])
p["in"].setInput(None)
with six.assertRaisesRegex(self, RuntimeError,
"Output not linked to input"):
e.processors()
with six.assertRaisesRegex(self, RuntimeError,
"Output not linked to input"):
e.acquireProcessor("Test")
def testSerialisation( self ) : s = Gaffer.ScriptNode() s["e"] = Gaffer.EditScope() s["e"].setup( Gaffer.IntPlug() ) p = s["e"].acquireProcessor( "Test" ) p["variables"].addChild( Gaffer.NameValuePlug( "x", 10, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) p2 = s2["e"].acquireProcessor( "Test", createIfNecessary = False ) self.assertIsNotNone( p2 ) self.assertEqual( type( p2 ), type( p ) ) self.assertEqual( p2["variables"][0]["name"].getValue(), p["variables"][0]["name"].getValue() ) self.assertEqual( p2["variables"][0]["value"].getValue(), p["variables"][0]["value"].getValue() ) self.assertEqual( s2["e"]["out"].getValue(), s["e"]["out"].getValue() )
def testAnimationHotkeyWithEditScopes(self):
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
script["editScope"] = Gaffer.EditScope()
script["editScope"].setup(script["cube"]["out"])
script["editScope"]["in"].setInput(script["cube"]["out"])
view = GafferSceneUI.SceneView()
view["in"].setInput(script["editScope"]["out"])
view["editScope"].setInput(script["editScope"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/cube"]))
tool = GafferSceneUI.TranslateTool(view)
tool["active"].setValue(True)
for plug in Gaffer.FloatPlug.RecursiveRange(
script["cube"]["transform"]):
self.assertFalse(Gaffer.Animation.isAnimated(plug))
self.assertFalse(
GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"],
"/cube"))
view.viewportGadget().keyPressSignal()(view.viewportGadget(),
GafferUI.KeyEvent("S"))
for plug in Gaffer.FloatPlug.RecursiveRange(
script["cube"]["transform"]):
self.assertFalse(Gaffer.Animation.isAnimated(plug))
self.assertTrue(
GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"],
"/cube"))
edit = GafferScene.EditScopeAlgo.acquireTransformEdit(
script["editScope"], "/cube")
for vectorPlug in (edit.translate, edit.rotate, edit.scale,
edit.pivot):
for plug in vectorPlug:
self.assertTrue(Gaffer.Animation.isAnimated(plug))
tool.translate(imath.V3f(1, 0, 0))
self.assertEqual(script["editScope"]["out"].transform("/cube"),
imath.M44f().translate(imath.V3f(1, 0, 0)))
def testTransformInEditScopeButEditScopeOff(self):
# Create an EditScope with an edit in it
script = Gaffer.ScriptNode()
script["sphere"] = GafferScene.Sphere()
script["editScope"] = Gaffer.EditScope()
script["editScope"].setup(script["sphere"]["out"])
script["editScope"]["in"].setInput(script["sphere"]["out"])
transformEdit = GafferScene.EditScopeAlgo.acquireTransformEdit(
script["editScope"], "/sphere")
transformEdit.translate.setValue(imath.V3f(1, 0, 0))
view = GafferSceneUI.SceneView()
view["in"].setInput(script["editScope"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/sphere"]))
# We want the TranslateTool to pick up and use that edit
# even if we haven't told it to use that EditScope.
tool = GafferSceneUI.TranslateTool(view)
tool["active"].setValue(True)
self.assertEqual(tool.handlesTransform(),
imath.M44f().translate(imath.V3f(1, 0, 0)))
self.assertEqual(len(tool.selection()), 1)
self.assertTrue(tool.selectionEditable())
self.assertTrue(tool.selection()[0].editable())
self.assertEqual(
tool.selection()[0].acquireTransformEdit(createIfNecessary=False),
transformEdit)
self.assertEqual(
tool.selection()[0].editTarget(),
transformEdit.translate.ancestor(Gaffer.Spreadsheet.RowPlug))
tool.translate(imath.V3f(0, 1, 0))
self.assertEqual(tool.handlesTransform(),
imath.M44f().translate(imath.V3f(1, 1, 0)))
self.assertEqual(transformEdit.translate.getValue(),
imath.V3f(1, 1, 0))
def testProcessorRegistry( self ) : self.assertIn( "Test", Gaffer.EditScope.registeredProcessors() ) def createProcessor() : n = Gaffer.TimeWarp() n.setup( Gaffer.IntPlug() ) return n Gaffer.EditScope.registerProcessor( "Test", createProcessor ) self.assertEqual( Gaffer.EditScope.registeredProcessors().count( "Test" ), 1 ) e = Gaffer.EditScope() e.setup( Gaffer.IntPlug() ) self.assertIsInstance( e.acquireProcessor( "Test" ), Gaffer.TimeWarp ) Gaffer.EditScope.deregisterProcessor( "Test" ) self.assertEqual( Gaffer.EditScope.registeredProcessors().count( "Test" ), 0 )
def testPruning( self ) : plane = GafferScene.Plane() cube = GafferScene.Cube() group = GafferScene.Group() group["in"][0].setInput( plane["out"] ) group["in"][1].setInput( cube["out"] ) scope = Gaffer.EditScope() scope.setup( group["out"] ) scope["in"].setInput( group["out"] ) self.assertEqual( len( list( GafferScene.SceneProcessor.Range( scope ) ) ), 0 ) self.assertFalse( GafferScene.EditScopeAlgo.getPruned( scope, "/group/plane" ) ) self.assertFalse( GafferScene.EditScopeAlgo.getPruned( scope, "/group/cube" ) ) self.assertEqual( len( list( GafferScene.SceneProcessor.Range( scope ) ) ), 0 ) self.assertTrue( GafferScene.SceneAlgo.exists( scope["out"], "/group/plane" ) ) self.assertTrue( GafferScene.SceneAlgo.exists( scope["out"], "/group/cube" ) ) GafferScene.EditScopeAlgo.setPruned( scope, "/group/plane", True ) self.assertTrue( GafferScene.EditScopeAlgo.getPruned( scope, "/group/plane" ) ) self.assertFalse( GafferScene.EditScopeAlgo.getPruned( scope, "/group/cube" ) ) self.assertEqual( len( list( GafferScene.SceneProcessor.Range( scope ) ) ), 1 ) self.assertEqual( scope["PruningEdits"]["paths"].getValue(), IECore.StringVectorData( [ "/group/plane" ] ) ) self.assertFalse( GafferScene.SceneAlgo.exists( scope["out"], "/group/plane" ) ) self.assertTrue( GafferScene.SceneAlgo.exists( scope["out"], "/group/cube" ) ) GafferScene.EditScopeAlgo.setPruned( scope, IECore.PathMatcher( [ "/group/plane", "/group/cube" ] ), True ) self.assertTrue( GafferScene.EditScopeAlgo.getPruned( scope, "/group/plane" ) ) self.assertTrue( GafferScene.EditScopeAlgo.getPruned( scope, "/group/cube" ) ) self.assertEqual( len( list( GafferScene.SceneProcessor.Range( scope ) ) ), 1 ) self.assertEqual( scope["PruningEdits"]["paths"].getValue(), IECore.StringVectorData( [ "/group/cube", "/group/plane" ] ) ) self.assertFalse( GafferScene.SceneAlgo.exists( scope["out"], "/group/plane" ) ) self.assertFalse( GafferScene.SceneAlgo.exists( scope["out"], "/group/cube" ) ) GafferScene.EditScopeAlgo.setPruned( scope, IECore.PathMatcher( [ "/group/plane", "/group/cube" ] ), False ) self.assertFalse( GafferScene.EditScopeAlgo.getPruned( scope, "/group/plane" ) ) self.assertFalse( GafferScene.EditScopeAlgo.getPruned( scope, "/group/cube" ) ) self.assertEqual( len( list( GafferScene.SceneProcessor.Range( scope ) ) ), 1 ) self.assertEqual( scope["PruningEdits"]["paths"].getValue(), IECore.StringVectorData() ) self.assertTrue( GafferScene.SceneAlgo.exists( scope["out"], "/group/plane" ) ) self.assertTrue( GafferScene.SceneAlgo.exists( scope["out"], "/group/cube" ) )
def testAcquireTransformEdit( self ) : plane = GafferScene.Plane() selection = GafferSceneUI.TransformTool.Selection( plane["out"], "/plane", Gaffer.Context(), None ) edit = selection.acquireTransformEdit() self.assertEqual( edit.translate, plane["transform"]["translate"] ) self.assertEqual( edit.rotate, plane["transform"]["rotate"] ) self.assertEqual( edit.scale, plane["transform"]["scale"] ) self.assertEqual( edit.pivot, plane["transform"]["pivot"] ) editScope = Gaffer.EditScope() editScope.setup( plane["out"] ) editScope["in"].setInput( plane["out"] ) selection = GafferSceneUI.TransformTool.Selection( editScope["out"], "/plane", Gaffer.Context(), editScope ) self.assertIsNone( selection.acquireTransformEdit( createIfNecessary = False ) ) edit = selection.acquireTransformEdit() self.assertTrue( editScope.isAncestorOf( edit.translate ) )
def testParameterEdits( self ) : light = GafferSceneTest.TestLight() editScope = Gaffer.EditScope() editScope.setup( light["out"] ) editScope["in"].setInput( light["out"] ) self.assertEqual( editScope["out"].attributes( "/light" )["light"].outputShader().parameters["intensity"].value, imath.Color3f( 0 ) ) self.assertFalse( GafferScene.EditScopeAlgo.hasParameterEdit( editScope, "/light", "light", ( "", "intensity" ) ) ) self.assertIsNone( GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "light", ( "", "intensity" ), createIfNecessary = False ) ) edit = GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "light", ( "", "intensity" ) ) self.assertIsInstance( edit, GafferScene.TweakPlug ) self.assertIsInstance( edit["value"], Gaffer.Color3fPlug ) self.assertEqual( edit["mode"].getValue(), GafferScene.TweakPlug.Mode.Replace ) self.assertEqual( edit["value"].getValue(), imath.Color3f( 0 ) ) self.assertEqual( edit["enabled"].getValue(), False ) edit["enabled"].setValue( True ) edit["value"].setValue( imath.Color3f( 1 ) ) self.assertEqual( editScope["out"].attributes( "/light" )["light"].outputShader().parameters["intensity"].value, imath.Color3f( 1 ) ) self.assertEqual( GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "light", ( "", "intensity" ) ), edit ) light["parameters"]["intensity"].setValue( imath.Color3f( 0.5 ) ) edit["enabled"].setValue( False ) self.assertEqual( editScope["out"].attributes( "/light" )["light"].outputShader().parameters["intensity"].value, imath.Color3f( 0.5 ) ) self.assertIsNone( GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "light", ( "", "__areaLight" ), createIfNecessary = False ) )
def testParameterEditSerialisation( self ) : script = Gaffer.ScriptNode() script["light1"] = GafferSceneTest.TestLight() script["light1"]["name"].setValue( "light1" ) script["light2"] = GafferSceneTest.TestLight() script["light2"]["name"].setValue( "light2" ) script["group"] = GafferScene.Group() script["group"]["in"][0].setInput( script["light1"]["out"] ) script["group"]["in"][1].setInput( script["light2"]["out"] ) script["editScope"] = Gaffer.EditScope() script["editScope"].setup( script["group"]["out"] ) script["editScope"]["in"].setInput( script["group"]["out"] ) edit1 = GafferScene.EditScopeAlgo.acquireParameterEdit( script["editScope"], "/group/light1", "light", ( "", "intensity" ) ) edit1["enabled"].setValue( True ) edit1["value"].setValue( imath.Color3f( 1, 2, 3 ) ) edit2 = GafferScene.EditScopeAlgo.acquireParameterEdit( script["editScope"], "/group/light2", "light", ( "", "__areaLight" ) ) edit2["enabled"].setValue( True ) edit2["value"].setValue( True ) script2 = Gaffer.ScriptNode() script2.execute( script.serialise() ) self.assertScenesEqual( script2["editScope"]["out"], script["editScope"]["out"] ) for path, parameter, enabled, value in [ ( "/group/light1", "intensity", True, imath.Color3f( 1, 2, 3 ) ), ( "/group/light1", "__areaLight", False, False ), ( "/group/light2", "intensity", False, imath.Color3f( 0 ) ), ( "/group/light2", "__areaLight", True, True ), ] : edit = GafferScene.EditScopeAlgo.acquireParameterEdit( script2["editScope"], path, "light", ( "", parameter ), createIfNecessary = False ) self.assertIsNotNone( edit ) self.assertEqual( edit["enabled"].getValue(), enabled ) self.assertEqual( edit["value"].getValue(), value )
def testTransformPerformance(self):
plane = GafferScene.Plane()
plane["divisions"].setValue(imath.V2i(100, 10))
cube = GafferScene.Cube()
planeFilter = GafferScene.PathFilter()
planeFilter["paths"].setValue(IECore.StringVectorData(["/plane"]))
instancer = GafferScene.Instancer()
instancer["in"].setInput(plane["out"])
instancer["prototypes"].setInput(cube["out"])
instancer["filter"].setInput(planeFilter["out"])
editScope = Gaffer.EditScope()
editScope.setup(instancer["out"])
editScope["in"].setInput(instancer["out"])
for name in instancer["out"].childNames("/plane/instances/cube"):
GafferScene.EditScopeAlgo.acquireTransformEdit(
editScope, "/plane/instances/cube/{}".format(name))
def testParameterEditExceptions( self ) : light = GafferSceneTest.TestLight() editScope = Gaffer.EditScope() editScope.setup( light["out"] ) editScope["in"].setInput( light["out"] ) emptyKeys = editScope.keys() with six.assertRaisesRegex( self, RuntimeError, 'Location "/bogus" does not exist' ) : GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/bogus", "light", ( "", "intensity" ) ) self.assertEqual( editScope.keys(), emptyKeys ) with six.assertRaisesRegex( self, RuntimeError, 'Attribute "bogus" does not exist' ) : GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "bogus", ( "", "intensity" ) ) self.assertEqual( editScope.keys(), emptyKeys ) with six.assertRaisesRegex( self, RuntimeError, 'Shader "bogus" does not exist' ) : GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "light", ( "bogus", "intensity" ) ) self.assertEqual( editScope.keys(), emptyKeys ) with six.assertRaisesRegex( self, RuntimeError, 'Parameter "bogus" does not exist' ) : GafferScene.EditScopeAlgo.acquireParameterEdit( editScope, "/light", "light", ( "", "bogus" ) ) self.assertEqual( editScope.keys(), emptyKeys )
def testAcquireProcessor(self):
e = Gaffer.EditScope()
e.setup(Gaffer.IntPlug())
self.assertIsNone(e.acquireProcessor("Test", createIfNecessary=False))
p = e.acquireProcessor("Test")
self.assertIsInstance(p, Gaffer.ContextVariables)
self.assertEqual(e["out"].source(), p["out"])
self.assertEqual(p["in"].source(), e["in"])
self.assertEqual(p, e.acquireProcessor("Test"))
# Remove processor from the main stream but keep it in the
# EditScope. A new processor should be made for us by
# `acquireProcessor()`.
p["out"].outputs()[0].setInput(p["in"].getInput())
self.assertIsNone(e.acquireProcessor("Test", createIfNecessary=False))
p2 = e.acquireProcessor("Test")
self.assertNotEqual(p, p2)
self.assertIsInstance(p2, Gaffer.ContextVariables)
self.assertEqual(e["out"].source(), p2["out"])
self.assertEqual(p2["in"].source(), e["in"])
