def test( self ) : ## \todo - this test just needs an arbitrary mesh with normals. # We should maybe have a more concise way of achieving this. How about a cow primitive? fileName = os.path.expandvars( "$GAFFER_ROOT/python/GafferTest/cobs/pSphereShape1.cob" ) read = Gaffer.ObjectReader() read["fileName"].setValue( fileName ) object = IECore.Reader.create( fileName ).read() p = GafferScene.ObjectToScene() p["object"].setInput( read["out"] ) m = GafferScene.MeshType() m["in"].setInput( p["out"] ) # Test unchanged settings. self.assertEqual( m["meshType"].getValue(), "" ) # do nothing self.assertEqual( p["out"].object( "/object" ), m["out"].object( "/object" ) ) self.assertScenesEqual( p["out"], m["out"] ) # Test converting poly to poly ( shouldn't do anything ) m["meshType"].setValue( "linear" ) self.assertEqual( p["out"].object( "/object" ), m["out"].object( "/object" ) ) self.assertScenesEqual( p["out"], m["out"] ) self.failUnless( "P" in m["out"].object( "/object" ) ) self.failUnless( "N" in m["out"].object( "/object" ) ) # Test converting poly to subdiv m["meshType"].setValue( "catmullClark" ) self.assertNotEqual( p["out"].object( "/object" ), m["out"].object( "/object" ) ) self.assertSceneHashesEqual( p["out"], m["out"], childPlugNames = ( "attributes", "bound", "transform", "globals", "childNames" ) ) self.assertScenesEqual( p["out"], m["out"], pathsToIgnore = ( "/object", ) ) self.assertEqual( m["out"].object( "/object" ).interpolation, "catmullClark" ) self.failUnless( "N" not in m["out"].object( "/object" ) ) # Test converting back to poly m2 = GafferScene.MeshType() m2["in"].setInput( m["out"] ) m2["meshType"].setValue( "linear" ) self.assertEqual( m2["out"].object( "/object" ).interpolation, "linear" ) self.assertTrue( "N" not in m2["out"].object( "/object" ) ) m2["calculatePolygonNormals"].setValue( True ) self.failUnless( "N" in m2["out"].object( "/object" ) )
def test(self):
r = GafferScene.SceneReader()
r["fileName"].setValue("${GAFFER_ROOT}/resources/cow/cow.scc")
m = GafferScene.MeshType()
m["in"].setInput(r["out"])
# Test unchanged settings.
self.assertEqual(m["meshType"].getValue(), "") # do nothing
self.assertEqual(r["out"].object("/cow"), m["out"].object("/cow"))
self.assertScenesEqual(r["out"], m["out"])
# Test converting poly to poly ( shouldn't do anything )
m["meshType"].setValue("linear")
self.assertEqual(r["out"].object("/cow"), m["out"].object("/cow"))
self.assertScenesEqual(r["out"], m["out"])
self.failUnless("P" in m["out"].object("/cow"))
self.failUnless("N" in m["out"].object("/cow"))
# Test converting poly to subdiv
m["meshType"].setValue("catmullClark")
self.assertNotEqual(r["out"].object("/cow"), m["out"].object("/cow"))
self.assertSceneHashesEqual(r["out"],
m["out"],
checks=self.allPathChecks - {"object"})
self.assertScenesEqual(r["out"], m["out"], pathsToIgnore=("/cow", ))
self.assertEqual(m["out"].object("/cow").interpolation, "catmullClark")
self.failUnless("N" not in m["out"].object("/cow"))
# Test converting back to poly
m2 = GafferScene.MeshType()
m2["in"].setInput(m["out"])
m2["meshType"].setValue("linear")
self.assertEqual(m2["out"].object("/cow").interpolation, "linear")
self.assertTrue("N" not in m2["out"].object("/cow"))
m2["calculatePolygonNormals"].setValue(True)
self.failUnless("N" in m2["out"].object("/cow"))
def testEnabledPlugAffects(self):
n = GafferScene.MeshType()
cs = GafferTest.CapturingSlot(n.plugDirtiedSignal())
n["enabled"].setValue(False)
self.assertIn(n["out"], {x[0] for x in cs})
def testEnabledPlugAffects(self):
n = GafferScene.MeshType()
cs = GafferTest.CapturingSlot(n.plugDirtiedSignal())
n["enabled"].setValue(False)
self.assertTrue(len(cs))
self.assertTrue(cs[1][0].isSame(n["out"]))
def testEditSubdivisionAttributes( self ) :
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
script["cube"]["dimensions"].setValue( IECore.V3f( 2 ) )
script["meshType"] = GafferScene.MeshType()
script["meshType"]["in"].setInput( script["cube"]["out"] )
script["meshType"]["meshType"].setValue( "catmullClark" )
script["attributes"] = GafferArnold.ArnoldAttributes()
script["attributes"]["in"].setInput( script["meshType"]["out"] )
script["attributes"]["attributes"]["subdivIterations"]["enabled"].setValue( True )
script["outputs"] = GafferScene.Outputs()
script["outputs"].addOutput(
"beauty",
IECoreScene.Display(
"test",
"ieDisplay",
"rgba",
{
"driverType" : "ImageDisplayDriver",
"handle" : "subdivisionTest",
}
)
)
script["outputs"]["in"].setInput( script["attributes"]["out"] )
script["objectToImage"] = GafferImage.ObjectToImage()
script["imageStats"] = GafferImage.ImageStats()
script["imageStats"]["in"].setInput( script["objectToImage"]["out"] )
script["imageStats"]["channels"].setValue( IECore.StringVectorData( [ "R", "G", "B", "A" ] ) )
script["imageStats"]["area"].setValue( IECore.Box2i( IECore.V2i( 0 ), IECore.V2i( 640, 480 ) ) )
script["render"] = self._createInteractiveRender()
script["render"]["in"].setInput( script["outputs"]["out"] )
# Render the cube with one level of subdivision. Check we get roughly the
# alpha coverage we expect.
script["render"]["state"].setValue( script["render"].State.Running )
time.sleep( 1 )
script["objectToImage"]["object"].setValue( IECoreImage.ImageDisplayDriver.storedImage( "subdivisionTest" ) )
self.assertAlmostEqual( script["imageStats"]["average"][3].getValue(), 0.381, delta = 0.001 )
# Now up the number of subdivision levels. The alpha coverage should
# increase as the shape tends towards the limit surface.
script["attributes"]["attributes"]["subdivIterations"]["value"].setValue( 4 )
time.sleep( 1 )
script["objectToImage"]["object"].setValue( IECoreImage.ImageDisplayDriver.storedImage( "subdivisionTest" ) )
self.assertAlmostEqual( script["imageStats"]["average"][3].getValue(), 0.424, delta = 0.001 )
def testNonPrimitiveObject( self ) : c = GafferScene.Camera() d = GafferScene.MeshType() d["in"].setInput( c["out"] ) self.assertSceneValid( d["out"] ) self.assertIsInstance( d["out"].object( "/camera" ), IECoreScene.Camera ) self.assertEqual( d["out"].object( "/camera" ), c["out"].object( "/camera" ) )
def testEditSubdivisionAttributes(self):
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
script["cube"]["dimensions"].setValue(imath.V3f(2))
script["meshType"] = GafferScene.MeshType()
script["meshType"]["in"].setInput(script["cube"]["out"])
script["meshType"]["meshType"].setValue("catmullClark")
script["attributes"] = GafferArnold.ArnoldAttributes()
script["attributes"]["in"].setInput(script["meshType"]["out"])
script["attributes"]["attributes"]["subdivIterations"][
"enabled"].setValue(True)
script["catalogue"] = GafferImage.Catalogue()
script["outputs"] = GafferScene.Outputs()
script["outputs"].addOutput(
"beauty",
IECoreScene.Output(
"test", "ieDisplay", "rgba", {
"driverType":
"ClientDisplayDriver",
"displayHost":
"localhost",
"displayPort":
str(script['catalogue'].displayDriverServer().portNumber()
),
"remoteDisplayType":
"GafferImage::GafferDisplayDriver",
}))
script["outputs"]["in"].setInput(script["attributes"]["out"])
script["imageStats"] = GafferImage.ImageStats()
script["imageStats"]["in"].setInput(script["catalogue"]["out"])
script["imageStats"]["channels"].setValue(
IECore.StringVectorData(["R", "G", "B", "A"]))
script["imageStats"]["area"].setValue(
imath.Box2i(imath.V2i(0), imath.V2i(640, 480)))
script["options"] = GafferScene.StandardOptions()
script["options"]["in"].setInput(script["outputs"]["out"])
script["options"]["options"]["filmFit"]["enabled"].setValue(True)
script["options"]["options"]["filmFit"]["value"].setValue(
IECoreScene.Camera.FilmFit.Fit)
script["render"] = self._createInteractiveRender()
script["render"]["in"].setInput(script["options"]["out"])
# Render the cube with one level of subdivision. Check we get roughly the
# alpha coverage we expect.
script["render"]["state"].setValue(script["render"].State.Running)
self.uiThreadCallHandler.waitFor(1)
self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(),
0.381,
delta=0.001)
# Now up the number of subdivision levels. The alpha coverage should
# increase as the shape tends towards the limit surface.
script["attributes"]["attributes"]["subdivIterations"][
"value"].setValue(4)
self.uiThreadCallHandler.waitFor(1)
self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(),
0.424,
delta=0.001)
script["render"]["state"].setValue(script["render"].State.Stopped)
def __init__(self, name="LDTShaderBall"):
GafferScene.SceneNode.__init__(self, name)
# Public plugs
self["shader"] = GafferScene.ShaderPlug()
self["resolution"] = Gaffer.IntPlug(
defaultValue=512, minValue=0
)
self["custom_geo"] = Gaffer.StringPlug(
defaultValue="${LOOKDEVTOOLS}/resources/abc/teapot.abc"
)
self["custom_geo_scale"] = Gaffer.FloatPlug(
defaultValue=1.0
)
# Private internal network
# Custom geo
self["__teapot"] = GafferScene.SceneReader()
self["__teapot"]["fileName"].setInput(
self["custom_geo"]
)
self["__teapot"]["transform"]["scale"].setValue(
imath.V3f(
0.0500000007, 0.0500000007, 0.0500000007
)
)
self["MeshType1"] = GafferScene.MeshType(
"MeshType1"
)
self["PathFilter7"] = GafferScene.PathFilter(
"PathFilter7"
)
self["MeshType1"]["filter"].setInput(
self["PathFilter7"]["out"]
)
self["MeshType1"]["meshType"].setValue(
"catmullClark"
)
self["PathFilter7"]["paths"].setValue(
IECore.StringVectorData(["/..."])
)
self["MeshType1"]["in"].setInput(
self["__teapot"]["out"]
)
# Root
self["__root"] = GafferScene.Group()
self["__root"]["transform"]["scale"]["x"].setInput(
self["custom_geo_scale"]
)
self["__root"]["transform"]["scale"]["y"].setInput(
self["custom_geo_scale"]
)
self["__root"]["transform"]["scale"]["z"].setInput(
self["custom_geo_scale"]
)
self["__root"]["in"][0].setInput(
self["MeshType1"]["out"]
)
self["__camera"] = GafferScene.Camera()
self["__camera"]["transform"]["translate"].setValue(
imath.V3f(0, 2.29999995, 9.5)
)
self["__camera"]["transform"]["rotate"].setValue(
imath.V3f(-9, 0, 0)
)
self["__camera"]["fieldOfView"].setValue(20.0)
self["__group"] = GafferScene.Group()
self["__group"]["in"][0].setInput(
self["__root"]["out"]
)
self["__group"]["in"][1].setInput(
self["__camera"]["out"]
)
# self["__group"]["in"][2].setInput(self["__plane"]["out"])
self["__subTree"] = GafferScene.SubTree()
self["__subTree"]["in"].setInput(
self["__group"]["out"]
)
self["__subTree"]["root"].setValue("/group")
self[
"__shaderAssignment"
] = GafferScene.ShaderAssignment()
self["__shaderAssignment"]["in"].setInput(
self["__subTree"]["out"]
)
self["__shaderAssignment"]["shader"].setInput(
self["shader"]
)
self["__options"] = GafferScene.StandardOptions()
self["__options"]["in"].setInput(
self["__shaderAssignment"]["out"]
)
self["__options"]["options"]["renderCamera"][
"enabled"
].setValue(True)
self["__options"]["options"]["renderCamera"][
"value"
].setValue("/camera")
self["__options"]["options"]["renderResolution"][
"enabled"
].setValue(True)
self["__options"]["options"]["renderResolution"][
"value"
][0].setInput(self["resolution"])
self["__options"]["options"]["renderResolution"][
"value"
][1].setInput(self["resolution"])
self["__emptyScene"] = GafferScene.ScenePlug()
self["__enabler"] = Gaffer.Switch()
self["__enabler"].setup(GafferScene.ScenePlug())
self["__enabler"]["in"][0].setInput(
self["__emptyScene"]
)
self["__enabler"]["in"][1].setInput(
self["__options"]["out"]
)
self["__enabler"]["enabled"].setInput(
self["enabled"]
)
self["__enabler"]["index"].setValue(1)
self["out"].setFlags(
Gaffer.Plug.Flags.Serialisable, False
)
self["out"].setInput(self["__enabler"]["out"])
def __init__(self, name="LDTShaderBall"):
GafferScene.SceneNode.__init__(self, name)
# Public plugs
self["shader"] = GafferScene.ShaderPlug()
self["resolution"] = Gaffer.IntPlug(
defaultValue=512, minValue=0
)
self["scene"] = Gaffer.IntPlug("scene")
Gaffer.Metadata.registerValue( self["scene"], 'nodule:type', '' )
Gaffer.Metadata.registerValue( self["scene"], 'plugValueWidget:type', 'GafferUI.PresetsPlugValueWidget' )
Gaffer.Metadata.registerValue( self["scene"], 'preset:shaderBall', 0 )
Gaffer.Metadata.registerValue( self["scene"], 'preset:customGeo', 1 )
self["custom_geo"] = Gaffer.StringPlug(
defaultValue="${LOOKDEVTOOLS}/resources/assets/teapot/teapot.abc"
)
# Private internal network
# ShaderBall
s = Gaffer.ScriptNode()
__shaderBallReference = s["__shaderBallReference"] = Gaffer.Reference()
__shaderBallReference.load("/run/media/ezequielm/misc/wrk/dev/EZLookdevTools/plugins/gaffer/boxes/LDTShaderBall.grf")
self.addChild(__shaderBallReference)
# Custom geo
self["__teapot"] = GafferScene.SceneReader()
self["__teapot"]["fileName"].setInput(
self["custom_geo"]
)
self["__teapot"]["transform"]["scale"].setValue(
imath.V3f(
1, 1, 1
)
)
self["__teapotMeshType"] = GafferScene.MeshType("__teapotMeshType")
self["__teapotPathFilter"] = GafferScene.PathFilter("__teapotPathFilter")
self["__teapotMeshType"]["filter"].setInput(self["__teapotPathFilter"]["out"])
self["__teapotMeshType"]["meshType"].setValue("catmullClark")
self["__teapotPathFilter"]["paths"].setValue(IECore.StringVectorData(["/..."]))
self["__teapotMeshType"]["in"].setInput(self["__teapot"]["out"])
self["__teapotSet"] = GafferScene.Set( "SHADERBALL_material" )
self["__teapotSet"]["name"].setValue( 'SHADERBALL:material' )
self["__teapotSet"]["filter"].setInput(self["__teapotPathFilter"]["out"])
self["__teapotSet"]["in"].setInput(self["__teapotMeshType"]["out"])
# Root
self["__sceneSwitch"] = Gaffer.Switch()
self["__sceneSwitch"].setup(GafferScene.ScenePlug( "in"))
self["__sceneSwitch"]["index"].setInput(self["scene"])
self["__sceneSwitch"]["in"].addChild( GafferScene.ScenePlug( "in0", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
self["__sceneSwitch"]["in"].addChild( GafferScene.ScenePlug( "in1", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
self["__sceneSwitch"]["in"]["in0"].setInput(self["__shaderBallReference"]["out"])
self["__sceneSwitch"]["in"]["in1"].setInput(self["__teapotSet"]["out"])
self["__camera"] = GafferScene.Camera()
self["__camera"]["transform"]["translate"].setValue(imath.V3f(0, 70, 175))
self["__camera"]["transform"]["rotate"].setValue(imath.V3f(-16, 0, 0))
self["__camera"]["fieldOfView"].setValue(20.0)
self["__group"] = GafferScene.Group()
self["__group"]["in"][0].setInput(
self["__sceneSwitch"]["out"]
)
self["__group"]["in"][1].setInput(
self["__camera"]["out"]
)
# self["__group"]["in"][2].setInput(self["__plane"]["out"])
self["__subTree"] = GafferScene.SubTree()
self["__subTree"]["in"].setInput(
self["__group"]["out"]
)
self["__subTree"]["root"].setValue("/group")
self["__shaderAssignment"] = GafferScene.ShaderAssignment()
self["__shaderAssignment"]["in"].setInput(
self["__subTree"]["out"]
)
self["__shaderAssignment"]["shader"].setInput(
self["shader"]
)
self["__shaderAssignmentFilter"] = GafferScene.SetFilter( "SetFilter" )
self["__shaderAssignmentFilter"]["setExpression"].setValue( 'SHADERBALL:material' )
self["__shaderAssignment"]["filter"].setInput(self["__shaderAssignmentFilter"]["out"])
self["__options"] = GafferScene.StandardOptions()
self["__options"]["in"].setInput(
self["__shaderAssignment"]["out"]
)
self["__options"]["options"]["renderCamera"][
"enabled"
].setValue(True)
self["__options"]["options"]["renderCamera"][
"value"
].setValue("/camera")
self["__options"]["options"]["renderResolution"][
"enabled"
].setValue(True)
self["__options"]["options"]["renderResolution"][
"value"
][0].setInput(self["resolution"])
self["__options"]["options"]["renderResolution"][
"value"
][1].setInput(self["resolution"])
self["__emptyScene"] = GafferScene.ScenePlug()
self["__enabler"] = Gaffer.Switch()
self["__enabler"].setup(GafferScene.ScenePlug())
self["__enabler"]["in"][0].setInput(
self["__emptyScene"]
)
self["__enabler"]["in"][1].setInput(
self["__options"]["out"]
)
self["__enabler"]["enabled"].setInput(
self["enabled"]
)
self["__enabler"]["index"].setValue(1)
self["out"].setFlags(
Gaffer.Plug.Flags.Serialisable, False
)
self["out"].setInput(self["__enabler"]["out"])
def testEditSubdivisionAttributes(self):
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
script["cube"]["dimensions"].setValue(IECore.V3f(2))
script["meshType"] = GafferScene.MeshType()
script["meshType"]["in"].setInput(script["cube"]["out"])
script["meshType"]["meshType"].setValue("catmullClark")
script["attributes"] = GafferArnold.ArnoldAttributes()
script["attributes"]["in"].setInput(script["meshType"]["out"])
script["attributes"]["attributes"]["subdivIterations"][
"enabled"].setValue(True)
script["outputs"] = GafferScene.Outputs()
script["outputs"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"driverType": "ClientDisplayDriver",
"displayType": "IECore::ClientDisplayDriver",
"displayHost": "localhost",
"displayPort": "2500",
"remoteDisplayType": "GafferImage::GafferDisplayDriver",
}))
script["outputs"]["in"].setInput(script["attributes"]["out"])
# Emulate the connection the UI makes, so the Display knows someone is listening and
# it needs to actually make servers.
dataReceivedConnection = GafferImage.Display.dataReceivedSignal(
).connect(lambda plug: None)
script["display"] = GafferImage.Display()
script["display"]["port"].setValue(2500)
script["imageStats"] = GafferImage.ImageStats()
script["imageStats"]["in"].setInput(script["display"]["out"])
script["imageStats"]["channels"].setValue(
IECore.StringVectorData(["R", "G", "B", "A"]))
script["imageStats"]["area"].setValue(
IECore.Box2i(IECore.V2i(0), IECore.V2i(640, 480)))
script["render"] = self._createInteractiveRender()
script["render"]["in"].setInput(script["outputs"]["out"])
# Render the cube with one level of subdivision. Check we get roughly the
# alpha coverage we expect.
script["render"]["state"].setValue(script["render"].State.Running)
time.sleep(1)
self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(),
0.381,
delta=0.001)
# Now up the number of subdivision levels. The alpha coverage should
# increase as the shape tends towards the limit surface.
script["attributes"]["attributes"]["subdivIterations"][
"value"].setValue(4)
time.sleep(1)
self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(),
0.424,
delta=0.001)
