def __init__(self, name="LDTShaderBallScene"):
GafferScene.SceneNode.__init__(self, name)
# Public plugs
self["shader"] = GafferScene.ShaderPlug()
self["resolution"] = Gaffer.IntPlug(defaultValue=512, minValue=0)
#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)
# Private internal network
# Camera
self["__camera"] = GafferScene.Camera()
self["__camera"]["transform"]["translate"].setValue(
imath.V3f(0, 86, 225))
self["__camera"]["transform"]["rotate"].setValue(imath.V3f(-16, 0, 0))
self["__camera"]["fieldOfView"].setValue(20.0)
# Env
self["__envMapFilename"] = Gaffer.StringPlug(
defaultValue="${GAFFER_ROOT}/resources/hdri/studio.exr")
# SkyDome
self["__envMap"] = GafferArnold.ArnoldShader()
self["__envMap"].loadShader("image")
self["__envMap"]["parameters"]["filename"].setInput(
self["__envMapFilename"])
self["__skyDome"] = GafferArnold.ArnoldLight()
self["__skyDome"].loadShader("skydome_light")
self["__skyDome"]["parameters"]["color"].setInput(
self["__envMap"]["out"])
self["__skyDome"]["parameters"]["format"].setValue("latlong")
# Expose Plugs
self.addChild(
self["__skyDome"]["parameters"]["exposure"].createCounterpart(
"exposure", Gaffer.Plug.Direction.In))
self["__skyDome"]["parameters"]["exposure"].setInput(self["exposure"])
# Join ShaderBall and Camera
self["__parent"] = GafferScene.Parent()
#self["__parent"]["in"].setInput(self["__shaderBallReference"]["out"])
self["__parent"]['children']['child0'].setInput(
self["__camera"]["out"])
self["__parent"]['children']['child1'].setInput(
self["__skyDome"]["out"])
self["__parent"]["parent"].setValue("/")
self["__shaderAssignment"] = GafferScene.ShaderAssignment()
self["__shaderAssignment"]["in"].setInput(self["__parent"]["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"])
# Standard Options
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)
# Expose Plugs
self["__options"]["options"]["renderResolution"]["value"][0].setInput(
self["resolution"])
self["__options"]["options"]["renderResolution"]["value"][1].setInput(
self["resolution"])
# Arnold Options
self["__arnoldOptions"] = GafferArnold.ArnoldOptions()
self["__arnoldOptions"]["in"].setInput(self["__options"]["out"])
self["__arnoldOptions"]["options"]["aaSamples"]["enabled"].setValue(
True)
self["__arnoldOptions"]["options"]["aaSamples"]["value"].setValue(3)
# Expose Plugs
self.addChild(
self["__arnoldOptions"]["options"]["threads"].createCounterpart(
"threads", Gaffer.Plug.Direction.In))
self["__arnoldOptions"]["options"]["threads"].setInput(self["threads"])
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["__arnoldOptions"]["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="_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"]["out"])
self["cameraRotate"] = GafferScene.Transform()
self["cameraRotate"]["in"].setInput(self["parentConstraint"]["out"])
self["cameraRotate"]["transform"]["rotate"]["y"].setInput(
self["angle"])
self["cameraRotate"]["filter"].setInput(self["cameraFilter"]["out"])
self["elevationExpression"] = Gaffer.Expression()
self["elevationExpression"].setExpression(
'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"]["filter"].setInput(self["cameraFilter"]["out"])
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 testConstruct(self):
p = GafferScene.Camera()
self.assertEqual(p.getName(), "Camera")
self.assertEqual(p["name"].getValue(), "camera")
def testKeepLightsAndCameras( self ) :
# - group
# - light
# - camera
# - model1
# - sphere
# - light
# - model2
# - sphere
# - light
light = GafferSceneTest.TestLight()
light["sets"].setValue( "lightsAndSpheres" )
sphere = GafferScene.Sphere()
sphere["sets"].setValue( "lightsAndSpheres" )
camera = GafferScene.Camera()
model1 = GafferScene.Group()
model1["in"][0].setInput( sphere["out"] )
model1["in"][1].setInput( light["out"] )
model1["name"].setValue( "model1" )
model2 = GafferScene.Group()
model2["in"][0].setInput( sphere["out"] )
model2["in"][1].setInput( light["out"] )
model2["name"].setValue( "model2" )
group = GafferScene.Group()
group["in"][0].setInput( light["out"] )
group["in"][1].setInput( camera["out"] )
group["in"][2].setInput( model1["out"] )
group["in"][3].setInput( model2["out"] )
self.assertSceneValid( group["out"] )
filter = GafferScene.PathFilter()
filter["paths"].setValue( IECore.StringVectorData( [ "/group/model1" ] ) )
isolate = GafferScene.Isolate()
isolate["in"].setInput( group["out"] )
isolate["filter"].setInput( filter["out"] )
# Keep neither
self.assertSceneValid( isolate["out"] )
self.assertTrue( GafferScene.SceneAlgo.exists( isolate["out"], "/group/model1/sphere" ) )
self.assertTrue( GafferScene.SceneAlgo.exists( isolate["out"], "/group/model1/light" ) )
self.assertTrue( GafferScene.SceneAlgo.exists( isolate["out"], "/group/model1" ) )
self.assertFalse( GafferScene.SceneAlgo.exists( isolate["out"], "/group/model2/sphere" ) )
self.assertFalse( GafferScene.SceneAlgo.exists( isolate["out"], "/group/model2" ) )
self.assertFalse( GafferScene.SceneAlgo.exists( isolate["out"], "/group/light" ) )
self.assertFalse( GafferScene.SceneAlgo.exists( isolate["out"], "/group/camera" ) )
self.assertEqual( isolate["out"].set( "__lights" ).value.paths(), [ "/group/model1/light" ] )
self.assertEqual( isolate["out"].set( "__cameras" ).value.paths(), [] )
self.assertEqual( isolate["out"].set( "lightsAndSpheres" ).value, GafferScene.PathMatcher( [ "/group/model1/sphere", "/group/model1/light" ] ) )
self.assertNotEqual( isolate["out"].setHash( "__lights" ), group["out"].setHash( "__lights" ) )
self.assertNotEqual( isolate["out"].setHash( "__cameras" ), group["out"].setHash( "__cameras" ) )
# Keep lights
isolate["keepLights"].setValue( True )
self.assertSceneValid( isolate["out"] )
self.assertFalse( GafferScene.SceneAlgo.exists( isolate["out"], "/group/camera" ) )
self.assertEqual( isolate["out"].set( "__lights" ), group["out"].set( "__lights" ) )
self.assertEqual( isolate["out"].set( "__cameras" ).value.paths(), [] )
self.assertEqual(
isolate["out"].set("lightsAndSpheres" ).value,
GafferScene.PathMatcher( [ "/group/model1/sphere" ] + group["out"].set( "__lights" ).value.paths() )
)
self.assertEqual( isolate["out"].setHash( "__lights" ), group["out"].setHash( "__lights" ) )
self.assertNotEqual( isolate["out"].setHash( "__cameras" ), group["out"].setHash( "__cameras" ) )
# Keep cameras too
isolate["keepCameras"].setValue( True )
self.assertSceneValid( isolate["out"] )
self.assertTrue( GafferScene.SceneAlgo.exists( isolate["out"], "/group/camera" ) )
self.assertEqual( isolate["out"].set( "__lights" ), group["out"].set( "__lights" ) )
self.assertEqual( isolate["out"].set( "__cameras" ), group["out"].set( "__cameras" ) )
self.assertEqual(
isolate["out"].set("lightsAndSpheres" ).value,
GafferScene.PathMatcher( [ "/group/model1/sphere" ] + group["out"].set( "__lights" ).value.paths() )
)
self.assertEqual( isolate["out"].setHash( "__lights" ), group["out"].setHash( "__lights" ) )
self.assertEqual( isolate["out"].setHash( "__cameras" ), group["out"].setHash( "__cameras" ) )
def testQuadLightTextureEdits(self):
# Quad light texture edits don't currently update correctly in Arnold.
# Check that our workaround is working
s = Gaffer.ScriptNode()
s["catalogue"] = GafferImage.Catalogue()
s["s"] = GafferScene.Sphere()
s["PathFilter"] = GafferScene.PathFilter("PathFilter")
s["PathFilter"]["paths"].setValue(IECore.StringVectorData(['/sphere']))
s["ShaderAssignment"] = GafferScene.ShaderAssignment(
"ShaderAssignment")
s["ShaderAssignment"]["in"].setInput(s["s"]["out"])
s["ShaderAssignment"]["filter"].setInput(s["PathFilter"]["out"])
s["lambert"], _ = self._createMatteShader()
s["ShaderAssignment"]["shader"].setInput(s["lambert"]["out"])
s["Tex"] = GafferArnold.ArnoldShader("image")
s["Tex"].loadShader("image")
s["Tex"]["parameters"]["filename"].setValue(
"${GAFFER_ROOT}/python/GafferArnoldTest/images/sphereLightBake.exr"
)
s["Tex"]["parameters"]["multiply"].setValue(imath.Color3f(1, 0, 0))
s["Light"] = GafferArnold.ArnoldLight("quad_light")
s["Light"].loadShader("quad_light")
s["Light"]["transform"]["translate"]["z"].setValue(2)
s["Light"]["parameters"]["color"].setInput(s["Tex"]["out"])
s["Light"]["parameters"]["exposure"].setValue(4)
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(2)
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["ShaderAssignment"]["out"])
s["group"]["in"][1].setInput(s["Light"]["out"])
s["group"]["in"][2].setInput(s["c"]["out"])
s["o"] = GafferScene.Outputs()
s["o"].addOutput(
"beauty",
IECoreScene.Output(
"test", "ieDisplay", "rgba", {
"driverType":
"ClientDisplayDriver",
"displayHost":
"localhost",
"displayPort":
str(s['catalogue'].displayDriverServer().portNumber()),
"remoteDisplayType":
"GafferImage::GafferDisplayDriver",
}))
s["o"]["in"].setInput(s["group"]["out"])
s["so"] = GafferScene.StandardOptions()
s["so"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["so"]["options"]["renderCamera"]["enabled"].setValue(True)
s["so"]["in"].setInput(s["o"]["out"])
s["r"] = self._createInteractiveRender()
s["r"]["in"].setInput(s["so"]["out"])
# Start rendering and make sure the light is linked to the sphere
s["r"]["state"].setValue(s["r"].State.Running)
self.uiThreadCallHandler.waitFor(1.0)
initialColor = self._color4fAtUV(s["catalogue"], imath.V2f(0.5))
self.assertAlmostEqual(initialColor.r, 0.09, delta=0.01)
self.assertAlmostEqual(initialColor.g, 0, delta=0.01)
# Edit texture network and make sure the changes take effect
s["Tex"]["parameters"]["multiply"].setValue(imath.Color3f(0, 1, 0))
self.uiThreadCallHandler.waitFor(1.0)
updateColor = self._color4fAtUV(s["catalogue"], imath.V2f(0.5))
self.assertAlmostEqual(updateColor.r, 0, delta=0.01)
self.assertAlmostEqual(updateColor.g, 0.06, delta=0.01)
s["r"]["state"].setValue(s["r"].State.Stopped)
def testLightLinkingAfterParameterUpdates(self):
s = Gaffer.ScriptNode()
s["s"] = GafferScene.Sphere()
s["PathFilter"] = GafferScene.PathFilter("PathFilter")
s["PathFilter"]["paths"].setValue(IECore.StringVectorData(['/sphere']))
s["ShaderAssignment"] = GafferScene.ShaderAssignment(
"ShaderAssignment")
s["ShaderAssignment"]["in"].setInput(s["s"]["out"])
s["ShaderAssignment"]["filter"].setInput(s["PathFilter"]["out"])
s["lambert"], _ = self._createMatteShader()
s["ShaderAssignment"]["shader"].setInput(s["lambert"]["out"])
s["StandardAttributes"] = GafferScene.StandardAttributes(
"StandardAttributes")
s["StandardAttributes"]["attributes"]["linkedLights"][
"enabled"].setValue(True)
s["StandardAttributes"]["attributes"]["linkedLights"][
"value"].setValue("defaultLights")
s["StandardAttributes"]["filter"].setInput(s["PathFilter"]["out"])
s["StandardAttributes"]["in"].setInput(s["ShaderAssignment"]["out"])
s["Light"] = GafferArnold.ArnoldLight("skydome_light")
s["Light"].loadShader("skydome_light")
s["FloatToRGB"] = GafferArnold.ArnoldShader("FloatToRGB")
s["FloatToRGB"].loadShader("float_to_rgb")
s["FloatToRGB"]["parameters"]["r"].setValue(1.0)
s["FloatToRGB"]["parameters"]["g"].setValue(1.0)
s["FloatToRGB"]["parameters"]["b"].setValue(1.0)
s["Light"]["parameters"]["color"].setInput(s["FloatToRGB"]["out"])
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(2)
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["StandardAttributes"]["out"])
s["group"]["in"][1].setInput(s["Light"]["out"])
s["group"]["in"][2].setInput(s["c"]["out"])
s["o"] = GafferScene.Outputs()
s["o"].addOutput(
"beauty",
IECoreScene.Output("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "litByEnvironment",
}))
s["o"]["in"].setInput(s["group"]["out"])
s["so"] = GafferScene.StandardOptions()
s["so"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["so"]["options"]["renderCamera"]["enabled"].setValue(True)
s["so"]["in"].setInput(s["o"]["out"])
s["r"] = self._createInteractiveRender()
s["r"]["in"].setInput(s["so"]["out"])
# Start rendering and make sure the light is linked to the sphere
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(0.5)
c = self._color3fAtUV(
IECoreImage.ImageDisplayDriver.storedImage("litByEnvironment"),
imath.V2f(0.5))
self.assertEqual(c, imath.Color3f(1.0))
# Change a value on the light. The light should still be linked to the sphere
# and we should get the same result as before.
s["Light"]['parameters']['shadow_density'].setValue(0.0)
time.sleep(0.5)
c = self._color3fAtUV(
IECoreImage.ImageDisplayDriver.storedImage("litByEnvironment"),
imath.V2f(0.5))
self.assertEqual(c, imath.Color3f(1.0))
def testBasic(self):
g = GafferScene.Group()
inputs = []
for shader, name in [
("spot_light", "spot1"),
("spot_light", "spot2"),
("distant_light", "distant1"),
("skydome_light", "env1"),
]:
l = GafferArnold.ArnoldLight()
l.loadShader(shader)
l["name"].setValue(name)
inputs.append(l)
inputs.append(GafferScene.Camera())
for i in inputs:
g["in"][-1].setInput(i["out"])
f = GafferScene.PathFilter()
f['paths'].setValue(
IECore.StringVectorData(
["/group/spot1", "/group/env1", "/group/distant1"]))
lc = GafferScene.LightToCamera()
lc["in"].setInput(g["out"])
lc["filter"].setInput(f["out"])
# Test spot to persp cam
spotCam = lc["out"].object("/group/spot1")
# Equality test fails on Mac: 64.99999237060547 != 65
calculatedFieldOfView = spotCam.calculateFieldOfView()
self.assertAlmostEqual(calculatedFieldOfView[0], 65, 4)
self.assertAlmostEqual(calculatedFieldOfView[1], 65, 4)
self.assertEqual(spotCam.getClippingPlanes(), imath.V2f(0.01, 100000))
self.assertEqual(spotCam.getProjection(), 'perspective')
self.assertEqual(spotCam.getFilmFit(), IECoreScene.Camera.FilmFit.Fit)
self.assertEqual(spotCam.hasResolution(), False)
# Test distant to ortho cam
distantCam = lc["out"].object("/group/distant1")
self.assertEqual(distantCam.getAperture(), imath.V2f(2, 2))
self.assertEqual(distantCam.getClippingPlanes(),
imath.V2f(-100000, 100000))
self.assertEqual(distantCam.getProjection(), 'orthographic')
self.assertEqual(distantCam.getFilmFit(),
IECoreScene.Camera.FilmFit.Fit)
self.assertEqual(distantCam.hasResolution(), False)
# Test light with no corresponding camera ( gets default cam )
self.assertEqual(
lc["out"].object("/group/env1").parameters(),
IECore.CompoundData({
'projection': IECore.StringData('perspective'),
}))
self.assertEqual(lc["out"].set("__lights").value.paths(),
["/group/spot2"])
self.assertEqual(
set(lc["out"].set("__cameras").value.paths()),
set([
"/group/camera", "/group/spot1", "/group/distant1",
"/group/env1"
]))
def testCustomPosition(self):
littleCube = GafferScene.Cube()
littleCube["name"].setValue("little")
bigCube = GafferScene.Cube()
bigCube["dimensions"].setValue(imath.V3f(10, 10, 10))
bigCube["name"].setValue("big")
camera = GafferScene.Camera()
camera["transform"]["translate"]["z"].setValue(10)
group = GafferScene.Group()
group["in"][0].setInput(littleCube["out"])
group["in"][1].setInput(bigCube["out"])
group["in"][2].setInput(camera["out"])
self.assertNotEqual(
group["out"].object("/group/little")["P"].data,
group["out"].object("/group/big")["P"].data,
)
bigCubeFilter = GafferScene.PathFilter()
bigCubeFilter["paths"].setValue(IECore.StringVectorData(["/group/big"
]))
shuffle = GafferScene.ShufflePrimitiveVariables()
shuffle["in"].setInput(group["out"])
shuffle["filter"].setInput(bigCubeFilter["out"])
shuffle["shuffles"].addChild(Gaffer.ShufflePlug("P", "Pref"))
littleCubeFilter = GafferScene.PathFilter()
littleCubeFilter["paths"].setValue(
IECore.StringVectorData(["/group/little"]))
copy = GafferScene.CopyPrimitiveVariables()
copy["in"].setInput(shuffle["out"])
copy["source"].setInput(shuffle["out"])
copy["filter"].setInput(littleCubeFilter["out"])
copy["sourceLocation"].setValue("/group/big")
copy["primitiveVariables"].setValue("Pref")
self.assertEqual(
copy["out"].object("/group/little")["Pref"].data,
copy["out"].object("/group/big")["Pref"].data,
)
unionFilter = GafferScene.UnionFilter()
unionFilter["in"][0].setInput(littleCubeFilter["out"])
unionFilter["in"][1].setInput(bigCubeFilter["out"])
projection = GafferScene.MapProjection()
projection["in"].setInput(copy["out"])
projection["filter"].setInput(unionFilter["out"])
projection["camera"].setValue("/group/camera")
projection["uvSet"].setValue("projectedUV")
self.assertNotEqual(
projection["out"].object("/group/little")["projectedUV"].data,
projection["out"].object("/group/big")["projectedUV"].data,
)
projection["position"].setValue("Pref")
self.assertEqual(
projection["out"].object("/group/little")["projectedUV"].data[0],
projection["out"].object("/group/big")["projectedUV"].data[0],
)
self.assertEqual(
projection["out"].object("/group/little")["projectedUV"].data,
projection["out"].object("/group/big")["projectedUV"].data,
)
def testLookThrough(self):
script = Gaffer.ScriptNode()
script["sphere"] = GafferScene.Sphere()
script["camera"] = GafferScene.Camera()
script["camera"]["transform"]["translate"].setValue(IECore.V3f(
1, 0, 0))
script["group"] = GafferScene.Group()
script["group"]["in"][0].setInput(script["sphere"]["out"])
script["group"]["in"][1].setInput(script["camera"]["out"])
with GafferUI.Window() as window:
viewer = GafferUI.Viewer(script)
window.setVisible(True)
viewer.setNodeSet(Gaffer.StandardSet([script["group"]]))
view = viewer.view()
self.assertTrue(isinstance(view, GafferSceneUI.SceneView))
def setViewCameraTransform(matrix):
camera = view.viewportGadget().getCamera()
camera.getTransform().matrix = matrix
view.viewportGadget().setCamera(camera)
def getViewCameraTransform():
return view.viewportGadget().getCamera().getTransform().transform()
# Simulate the user translating the camera.
setViewCameraTransform(
IECore.M44f.createTranslated(IECore.V3f(100, 0, 0)))
self.assertEqual(getViewCameraTransform(),
IECore.M44f.createTranslated(IECore.V3f(100, 0, 0)))
# Set the path for the look-through camera, but don't activate it - nothing should have changed.
view["lookThrough"]["camera"].setValue("/group/camera")
self.assertEqual(getViewCameraTransform(),
IECore.M44f.createTranslated(IECore.V3f(100, 0, 0)))
# Enable the look-through - the camera should update.
view["lookThrough"]["enabled"].setValue(True)
self.waitForIdle()
self.assertEqual(getViewCameraTransform(),
script["group"]["out"].transform("/group/camera"))
# Disable the look-through - the camera should revert to its previous position.
view["lookThrough"]["enabled"].setValue(False)
self.waitForIdle()
self.assertEqual(getViewCameraTransform(),
IECore.M44f.createTranslated(IECore.V3f(100, 0, 0)))
# Simulate the user moving the viewport camera, and then move the (now disabled) look-through
# camera. The user movement should win out.
setViewCameraTransform(
IECore.M44f.createTranslated(IECore.V3f(200, 0, 0)))
self.assertEqual(getViewCameraTransform(),
IECore.M44f.createTranslated(IECore.V3f(200, 0, 0)))
script["camera"]["transform"]["translate"].setValue(IECore.V3f(
2, 0, 0))
self.waitForIdle()
self.assertEqual(getViewCameraTransform(),
IECore.M44f.createTranslated(IECore.V3f(200, 0, 0)))
# Change the viewer context - since look-through is disabled the user camera should not move.
viewer.getContext().setFrame(10)
self.waitForIdle()
self.assertEqual(getViewCameraTransform(),
IECore.M44f.createTranslated(IECore.V3f(200, 0, 0)))
# Work around "Internal C++ object (PySide.QtGui.QWidget) already deleted" error. In an
# ideal world we'll fix this, but it's unrelated to what we're testing here.
window.removeChild(viewer)
def __init__( self, name = "__CameraSetup" ) :
GafferScene.FilteredSceneProcessor.__init__( self, name )
# Public plugs
self["cameraGroup"] = Gaffer.StringPlug( "cameraGroup", Gaffer.Plug.Direction.In, "__TEXTUREBAKE_CAMERAS" )
self["bakeDirectory"] = Gaffer.StringPlug( "bakeDirectory", Gaffer.Plug.Direction.In, "" )
self["defaultFileName"] = Gaffer.StringPlug( "defaultFileName", Gaffer.Plug.Direction.In, "${bakeDirectory}/<AOV>/<AOV>.<UDIM>.exr" )
self["defaultResolution"] = Gaffer.IntPlug( "defaultResolution", Gaffer.Plug.Direction.In, 512 )
self["uvSet"] = Gaffer.StringPlug( "uvSet", Gaffer.Plug.Direction.In, "uv" )
self["udims"] = Gaffer.StringPlug( "udims", Gaffer.Plug.Direction.In, "" )
self["normalOffset"] = Gaffer.FloatPlug( "normalOffset", Gaffer.Plug.Direction.In, 0.1 )
self["aovs"] = Gaffer.StringPlug( "aovs", Gaffer.Plug.Direction.In, "beauty:rgba" )
self["tasks"] = Gaffer.IntPlug( "tasks", Gaffer.Plug.Direction.In, 1 )
self["taskIndex"] = Gaffer.IntPlug( "taskIndex", Gaffer.Plug.Direction.In, 0 )
# Output
self["renderFileList"] = Gaffer.StringVectorDataPlug( "renderFileList", Gaffer.Plug.Direction.Out, defaultValue = IECore.StringVectorData() )
self["renderFileList"].setFlags( Gaffer.Plug.Flags.Serialisable, False )
# Private internal network
self["__udimQuery"] = GafferScene.UDIMQuery()
self["__udimQuery"]["in"].setInput( self["in"] )
self["__udimQuery"]["uvSet"].setInput( self["uvSet"] )
self["__udimQuery"]["attributes"].setValue( "bake:resolution bake:fileName" )
self["__udimQuery"]["filter"].setInput( self["filter"] )
self["__chunkedBakeInfo"] = Gaffer.CompoundObjectPlug( "__chunkedBakeInfo", Gaffer.Plug.Direction.In, IECore.CompoundObject() )
self["__chunkedBakeInfo"].setFlags( Gaffer.Plug.Flags.Serialisable, False )
self["__chunkExpression"] = Gaffer.Expression()
self["__chunkExpression"].setExpression( inspect.cleandoc(
"""
import collections
import re
rawInfo = parent["__udimQuery"]["out"]
defaultFileName = parent["defaultFileName"]
defaultResolution = parent["defaultResolution"]
selectUdimsStr = parent["udims"]
# FrameList really ought to take care of this check, instead of just doing
# something obviously wrong
if re.match( ".*[0-9] +[0-9].*", selectUdimsStr ):
raise RuntimeError( "ArnoldTextureBake : Udim list must be comma separated." )
selectUdims = set( IECore.FrameList.parse( selectUdimsStr ).asList() )
allMeshes = collections.defaultdict( lambda : [] )
for udim, meshes in rawInfo.items():
if selectUdims and not int( udim ) in selectUdims:
continue
for mesh, extraAttributes in meshes.items():
resolution = defaultResolution
if "bake:resolution" in extraAttributes:
resolution = extraAttributes["bake:resolution"].value
fileName = defaultFileName
if "bake:fileName" in extraAttributes:
fileName = extraAttributes["bake:fileName"].value
allMeshes[ (fileName, udim) ].append( { "mesh" : mesh, "resolution" : resolution } )
fileList = sorted( allMeshes.keys() )
info = IECore.CompoundObject()
numTasks = min( parent["tasks"], len( fileList ) )
taskIndex = parent["taskIndex"]
if taskIndex < numTasks:
chunkStart = ( taskIndex * len( fileList ) ) / numTasks
chunkEnd = ( ( taskIndex + 1 ) * len( fileList ) ) / numTasks
dupeCount = 0
prevFileName = ""
for fileNameTemplate, udim in fileList[chunkStart:chunkEnd]:
for meshData in allMeshes[(fileNameTemplate, udim)]:
o = IECore.CompoundObject()
o["mesh"] = IECore.StringData( meshData["mesh"] )
o["udim"] = IECore.IntData( int( udim ) )
o["resolution"] = IECore.IntData( meshData["resolution"] )
udimStr = str( udim )
fileName = fileNameTemplate.replace( "<UDIM>", udimStr )
if fileName == prevFileName:
dupeCount += 1
fileName = fileName + ".layer" + str( dupeCount )
else:
prevFileName = fileName
dupeCount = 0
o["fileName"] = IECore.StringData( fileName )
name = o["mesh"].value.replace( "/", "_" ) + "." + udimStr
info[ name ] = o
parent["__chunkedBakeInfo"] = info
fileList = []
for name, i in info.items():
fileName = i["fileName"].value
for nameAndAov in parent["aovs"].strip( " " ).split( " " ):
fileList.append( i["fileName"].value.replace( "<AOV>", nameAndAov.split(":")[0] ) )
parent["renderFileList"] = IECore.StringVectorData( fileList )
"""
), "python" )
self["__parent"] = GafferScene.Parent()
self["__parent"]["parent"].setValue( "/" )
for c in ['bound', 'transform', 'attributes', 'object', 'childNames', 'setNames', 'set']:
self["__parent"]["in"][c].setInput( self["in"][c] )
self["__outputExpression"] = Gaffer.Expression()
self["__outputExpression"].setExpression( inspect.cleandoc(
"""
import IECoreScene
# Transfer all input globals except for outputs
inGlobals = parent["in"]["globals"]
outGlobals = IECore.CompoundObject()
for key, value in inGlobals.items():
if not key.startswith( "output:" ):
outGlobals[key] = value
# Make our own outputs
info = parent["__chunkedBakeInfo"]
for cameraName, i in info.items():
params = IECore.CompoundData()
fileName = i["fileName"].value
params["camera"] = IECore.StringData( "/" + parent["cameraGroup"] + "/" + cameraName )
for nameAndAov in parent["aovs"].strip( " " ).split( " " ):
tokens = nameAndAov.split( ":" )
if len( tokens ) != 2:
raise RuntimeError( "Invalid bake aov specification: %s It should contain a : between name and data." )
( aovName, aov ) = tokens
aovFileName = fileName.replace( "<AOV>", aovName )
outGlobals["output:" + cameraName + "." + aov] = IECoreScene.Output( aovFileName, "exr", aov + " RGBA", params )
parent["__parent"]["in"]["globals"] = outGlobals
"""
), "python" )
self["__camera"] = GafferScene.Camera()
self["__camera"]["projection"].setValue( "orthographic" )
self["__cameraTweaks"] = GafferScene.CameraTweaks()
self["__cameraTweaks"]["in"].setInput( self["__camera"]["out"] )
self["__cameraTweaks"]["tweaks"]["projection"] = GafferScene.TweakPlug( "projection", "uv_camera" )
self["__cameraTweaks"]["tweaks"]["resolution"] = GafferScene.TweakPlug( "resolution", imath.V2i( 0 ) )
self["__cameraTweaks"]["tweaks"]["u_offset"] = GafferScene.TweakPlug( "u_offset", 0.0 )
self["__cameraTweaks"]["tweaks"]["v_offset"] = GafferScene.TweakPlug( "v_offset", 0.0 )
self["__cameraTweaks"]["tweaks"]["mesh"] = GafferScene.TweakPlug( "mesh", "" )
self["__cameraTweaks"]["tweaks"]["uv_set"] = GafferScene.TweakPlug( "uv_set", "" )
self["__cameraTweaks"]["tweaks"]["extend_edges"] = GafferScene.TweakPlug( "extend_edges", False )
self["__cameraTweaks"]["tweaks"]["offset"] = GafferScene.TweakPlug( "offset", 0.1 )
self["__cameraTweaks"]["tweaks"]["offset"]["value"].setInput( self["normalOffset"] )
self["__cameraTweaksFilter"] = GafferScene.PathFilter()
self["__cameraTweaksFilter"]["paths"].setValue( IECore.StringVectorData( [ '/camera' ] ) )
self["__cameraTweaks"]["filter"].setInput( self["__cameraTweaksFilter"]["out"] )
self["__collectScenes"] = GafferScene.CollectScenes()
self["__collectScenes"]["sourceRoot"].setValue( "/camera" )
self["__collectScenes"]["rootNameVariable"].setValue( "collect:cameraName" )
self["__collectScenes"]["in"].setInput( self["__cameraTweaks"]["out"] )
self["__group"] = GafferScene.Group()
self["__group"]["in"][0].setInput( self["__collectScenes"]["out"] )
self["__group"]["name"].setInput( self["cameraGroup"] )
self["__parent"]["children"][0].setInput( self["__group"]["out"] )
self["__collectSceneRootsExpression"] = Gaffer.Expression()
self["__collectSceneRootsExpression"].setExpression( inspect.cleandoc(
"""
info = parent["__chunkedBakeInfo"]
parent["__collectScenes"]["rootNames"] = IECore.StringVectorData( info.keys() )
"""
), "python" )
self["__cameraSetupExpression"] = Gaffer.Expression()
self["__cameraSetupExpression"].setExpression( inspect.cleandoc(
"""
cameraName = context["collect:cameraName"]
info = parent["__chunkedBakeInfo"]
i = info[cameraName]
udimOffset = i["udim"].value - 1001
parent["__cameraTweaks"]["tweaks"]["resolution"]["value"] = imath.V2i( i["resolution"].value )
parent["__cameraTweaks"]["tweaks"]["u_offset"]["value"] = -( udimOffset % 10 )
parent["__cameraTweaks"]["tweaks"]["v_offset"]["value"] = -( udimOffset / 10 )
parent["__cameraTweaks"]["tweaks"]["mesh"]["value"] = i["mesh"].value
parent["__cameraTweaks"]["tweaks"]["uv_set"]["value"] = parent["uvSet"] if parent["uvSet"] != "uv" else ""
"""
), "python" )
self["out"].setFlags( Gaffer.Plug.Flags.Serialisable, False )
self["out"].setInput( self["__parent"]["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 __populateMetadata():
global _parameterCategoriesAndDefaults
plugMetadata = {
"tweaks": [
"description",
"""
The tweaks to be made to the parameters of the camera.
Arbitrary numbers of user defined tweaks may be
added as children of this plug via the user
interface, or using the CameraTweaks API via python.
""",
"plugValueWidget:type",
"GafferUI.LayoutPlugValueWidget",
"layout:customWidget:footer:widgetType",
"GafferSceneUI.CameraTweaksUI._TweaksFooter",
"layout:customWidget:footer:index",
-1,
],
"tweaks.*": [
"tweakPlugValueWidget:allowRemove",
True,
],
}
# Create a temporary camera object just to read the default parameter values off of it,
# and access the metadata
tempCam = GafferScene.Camera()
parameterCategories = [("Camera Parameters", i) for i in [
"projection", "fieldOfView", "apertureAspectRatio", "aperture",
"focalLength", "apertureOffset", "fStop", "focalLengthWorldScale",
"focusDistance", "clippingPlanes"
]] + [("Render Overrides", i) for i in [
"filmFit", "shutter", "resolution", "pixelAspectRatio",
"resolutionMultiplier", "overscan", "overscanLeft", "overscanRight",
"overscanTop", "overscanBottom", "cropWindow", "depthOfField"
]]
for category, plugName in parameterCategories:
if category == "Render Overrides":
cameraPlug = tempCam["renderSettingOverrides"][plugName]["value"]
else:
cameraPlug = tempCam[plugName]
data = Gaffer.PlugAlgo.extractDataFromPlug(cameraPlug)
_parameterCategoriesAndDefaults.append((category, plugName, data))
plugMetadata["tweaks.tweak_%s*.name" % plugName] = ["readOnly", True]
valueMetadata = []
for metaName in Gaffer.Metadata.registeredValues(cameraPlug):
metaValue = Gaffer.Metadata.value(cameraPlug, metaName)
if metaName != "layout:section" and not metaValue is None:
valueMetadata.append(metaName)
valueMetadata.append(metaValue)
# The Camera node only offers a choice between "perspective" and "orthographic", since
# they are the two that make sense in the UI. But if you're putting down a special
# tweak node, you might want to use a non-standard camera supported by your specific
# renderer backend ( eg. spherical_camera in Arnold )
if plugName == "projection":
valueMetadata.append("presetsPlugValueWidget:allowCustom")
valueMetadata.append(True)
plugMetadata["tweaks.tweak_%s*.value" % plugName] = valueMetadata
Gaffer.Metadata.registerNode(GafferScene.CameraTweaks,
"description",
"""
Makes modifications to camera parameter values.
""",
plugs=plugMetadata)
def testClippingPlanesAndFOV(self):
script = Gaffer.ScriptNode()
script["camera"] = GafferScene.Camera()
view = GafferUI.View.create(script["camera"]["out"])
def assertDefaultCamera():
# Force update
view.viewportGadget().preRenderSignal()(view.viewportGadget())
self.assertEqual(
view["camera"]["clippingPlanes"].getValue(),
view.viewportGadget().getCamera().parameters()
["clippingPlanes"].value)
self.assertAlmostEqual(
view["camera"]["fieldOfView"].getValue(),
view.viewportGadget().getCamera().calculateFieldOfView()[0],
places=5)
assertDefaultCamera()
view["camera"]["clippingPlanes"].setValue(imath.V2f(1, 10))
assertDefaultCamera()
view["camera"]["fieldOfView"].setValue(40)
assertDefaultCamera()
def assertLookThroughCamera():
# Force update
view.viewportGadget().preRenderSignal()(view.viewportGadget())
self.assertEqual(
script["camera"]["clippingPlanes"].getValue(),
view.viewportGadget().getCamera().parameters()
["clippingPlanes"].value)
self.assertAlmostEqual(
script["camera"]["fieldOfView"].getValue(),
view.viewportGadget().getCamera().calculateFieldOfView()[0],
places=5)
# Quick hack - in order to compare FOV, we don't want the 40 border pixels added to the viewport
# camera to be a significant part of the FOV. Just set the resolution to be enormous so that the
# border is insignificant
view.viewportGadget().setViewport(imath.V2i(10000000000000))
view["camera"]["lookThroughCamera"].setValue("/camera")
view["camera"]["lookThroughEnabled"].setValue(True)
assertLookThroughCamera()
view["camera"]["lookThroughEnabled"].setValue(False)
assertDefaultCamera()
view["camera"]["lookThroughEnabled"].setValue(True)
assertLookThroughCamera()
view["camera"]["clippingPlanes"].setValue(imath.V2f(10, 20))
view["camera"]["fieldOfView"].setValue(60)
assertLookThroughCamera()
view["camera"]["lookThroughEnabled"].setValue(False)
assertDefaultCamera()
def testFrustum(self):
c = GafferScene.Camera()
self.assertAlmostEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
2.0 * math.tan(0.5 * math.radians(c["fieldOfView"].getValue())),
places=6)
c["fieldOfView"].setValue(100)
self.assertAlmostEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
2.0 * math.tan(0.5 * math.radians(c["fieldOfView"].getValue())),
places=6)
self.assertAlmostEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[1] * 2.0,
2.0 * math.tan(0.5 * math.radians(c["fieldOfView"].getValue())),
places=6)
c["apertureAspectRatio"].setValue(3)
self.assertAlmostEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
2.0 * math.tan(0.5 * math.radians(c["fieldOfView"].getValue())),
places=6)
self.assertAlmostEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[1] * 2.0,
2.0 / 3.0 *
math.tan(0.5 * math.radians(c["fieldOfView"].getValue())),
places=6)
c["perspectiveMode"].setValue(
GafferScene.Camera.PerspectiveMode.ApertureFocalLength)
self.assertNotAlmostEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
2.0 * math.tan(0.5 * math.radians(c["fieldOfView"].getValue())),
places=6)
self.assertAlmostEqual(c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
c["aperture"].getValue()[0] /
c["focalLength"].getValue(),
places=6)
c["aperture"].setValue(imath.V2f(100))
self.assertAlmostEqual(c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
c["aperture"].getValue()[0] /
c["focalLength"].getValue(),
places=6)
c["focalLength"].setValue(200)
self.assertAlmostEqual(c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
c["aperture"].getValue()[0] /
c["focalLength"].getValue(),
places=6)
c["projection"].setValue("orthographic")
self.assertNotAlmostEqual(c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max()[0] * 2.0,
c["aperture"].getValue()[0] /
c["focalLength"].getValue(),
places=6)
self.assertEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max() * 2.0,
c["orthographicAperture"].getValue())
c["orthographicAperture"].setValue(imath.V2f(0.1, 12))
self.assertEqual(
c["out"].object("/camera").frustum(
IECoreScene.Camera.FilmFit.Distort).max() * 2.0,
c["orthographicAperture"].getValue())
def testMoveCoordinateSystem(self):
shader = self.compileShader(
os.path.dirname(__file__) + "/shaders/coordSysDot.sl")
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["shader"] = GafferRenderMan.RenderManShader()
s["shader"].loadShader(shader)
s["shader"]["parameters"]["coordSys"].setValue(
"/group/coordinateSystem")
s["shaderAssignment"] = GafferScene.ShaderAssignment()
s["shaderAssignment"]["in"].setInput(s["plane"]["out"])
s["shaderAssignment"]["shader"].setInput(s["shader"]["out"])
s["camera"] = GafferScene.Camera()
s["camera"]["transform"]["translate"]["z"].setValue(1)
s["coordSys"] = GafferScene.CoordinateSystem()
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["shaderAssignment"]["out"])
s["g"]["in"][1].setInput(s["camera"]["out"])
s["g"]["in"][2].setInput(s["coordSys"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
s["d"]["in"].setInput(s["g"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertAlmostEqual(c[1], 1, delta=0.001)
# move the coordinate system, and check the output
s["coordSys"]["transform"]["translate"]["x"].setValue(0.1)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.6, 0.5),
)
self.assertAlmostEqual(c[0], 1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.6, 0.7),
)
self.assertAlmostEqual(c[0], 0)
# scale the coordinate system to cover everything, and check again
s["coordSys"]["transform"]["scale"].setValue(IECore.V3f(100))
time.sleep(2)
for p in [
IECore.V2f(0.5),
IECore.V2f(0.15),
IECore.V2f(0.85),
]:
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
p,
)
self.assertAlmostEqual(c[0], 1, delta=0.001)
def testRender(self):
s = Gaffer.ScriptNode()
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
s["l"]["transform"]["translate"]["z"].setValue(1)
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["l"]["out"])
s["g"]["in"][1].setInput(s["p"]["out"])
s["g"]["in"][2].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("matte")
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
self.temporaryDirectory() + "/testRenderManLight.exr", "exr",
"rgba", {"quantize": IECore.FloatVectorData([0, 0, 0, 0])}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.RenderManRender()
s["r"]["ribFileName"].setValue(self.temporaryDirectory() +
"/testRenderManLight.rib")
s["r"]["in"].setInput(s["o"]["out"])
# must save the script for the procedural to load it
# in the render process. if we were using a dispatcher,
# that would have saved the script for us, but we're
# calling execute() directly so it is our responsibility.
s["fileName"].setValue(self.temporaryDirectory() +
"/testRenderManLight.gfr")
s.save()
s["r"].execute()
i = IECore.EXRImageReader(self.temporaryDirectory() +
"/testRenderManLight.exr").read()
e = IECore.ImagePrimitiveEvaluator(i)
r = e.createResult()
e.pointAtUV(IECore.V2f(0.5), r)
self.assertEqual(r.floatPrimVar(e.R()), 1)
self.assertEqual(r.floatPrimVar(e.G()), 0.5)
self.assertEqual(r.floatPrimVar(e.B()), 0.25)
def testSceneViewStatus(self):
camera = GafferScene.Camera()
view = GafferUI.View.create(camera["out"])
tool = GafferSceneUI.CropWindowTool(view)
tool["active"].setValue(True)
# Presently, crop window tool updates are coupled to `preRender`, so we
# need to actually show the View before we can verify our behaviour.
with GafferUI.Window() as window:
GafferUI.GadgetWidget(view.viewportGadget())
window.setVisible(True)
# View camera isn't a real camera
self.waitForIdle(1000)
self.assertEqual(tool.status(),
"Error: No applicable crop window for this view")
# Working camera, no node to edit
view["camera"]["lookThroughCamera"].setValue("/camera")
view["camera"]["lookThroughEnabled"].setValue(True)
self.waitForIdle(1000)
self.assertEqual(
tool.status(),
"Error: No crop window found. Insert a <b>StandardOptions</b> node."
)
# Editable
options = GafferScene.StandardOptions()
options["in"].setInput(camera["out"])
view["in"].setInput(options["out"])
self.waitForIdle(1000)
self.assertEqual(
tool.status(),
"Info: Editing <b>StandardOptions.options.renderCropWindow.value</b>"
)
# Locked value plug
Gaffer.MetadataAlgo.setReadOnly(
options["options"]["renderCropWindow"]["value"], True)
self.waitForIdle(1000)
self.assertEqual(
tool.status(),
"Warning: <b>StandardOptions.options.renderCropWindow.value</b> is locked"
)
# Locked/off enabled plug
Gaffer.MetadataAlgo.setReadOnly(
options["options"]["renderCropWindow"]["value"], False)
options["options"]["renderCropWindow"]["enabled"].setValue(False)
Gaffer.MetadataAlgo.setReadOnly(
options["options"]["renderCropWindow"]["enabled"], True)
self.waitForIdle(1000)
self.assertEqual(
tool.status(),
"Warning: <b>StandardOptions.options.renderCropWindow.value</b> isn't editable"
)
# Check status across visible/invisible overlay transitions (this is
# really testing one of the gnarly parts of the status implementation
# that has caused trouble before, until we can properly refactor the tool).
view["camera"]["lookThroughEnabled"].setValue(False)
self.waitForIdle(1000)
self.assertEqual(tool.status(),
"Error: No applicable crop window for this view")
view["camera"]["lookThroughEnabled"].setValue(True)
self.waitForIdle(1000)
self.assertEqual(
tool.status(),
"Warning: <b>StandardOptions.options.renderCropWindow.value</b> isn't editable"
)
def testAttributes(self):
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["p"]["transform"]["translate"].setValue(IECore.V3f(-0.1, -0.1, 0))
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["p"]["out"])
s["g"]["in"][1].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader(
self.compileShader(os.path.dirname(__file__) + "/shaders/flat.sl"))
s["s"]["parameters"]["c"].setValue(IECore.Color3f(1, 0.5, 0.25))
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(1, 0.5, 0.25))
# adjust a shader parameter, wait, and check that it changed
s["s"]["parameters"]["c"].setValue(IECore.Color3f(1, 1, 1))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(1))
# turn off shader updates, do the same, and check that it hasn't changed
s["r"]["updateAttributes"].setValue(False)
s["s"]["parameters"]["c"].setValue(IECore.Color3f(0.5))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(1))
# turn shader updates back on, and check that it updates
s["r"]["updateAttributes"].setValue(True)
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c, IECore.Color3f(0.5))
def testRenderRegion( self ) : s = Gaffer.ScriptNode() s["camera"] = GafferScene.Camera() s["options"] = GafferScene.StandardOptions() s["options"]["in"].setInput( s["camera"]["out"] ) s["options"]["options"]["renderCamera"]["enabled"].setValue( True ) s["options"]["options"]["renderCamera"]["value"].setValue( "/camera" ) s["render"] = GafferArnold.ArnoldRender() s["render"]["in"].setInput( s["options"]["out"] ) s["render"]["mode"].setValue( s["render"].Mode.SceneDescriptionMode ) s["render"]["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) # Default region s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 639 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 479 ) # Apply Crop Window s["options"]["options"]["renderCropWindow"]["enabled"].setValue( True ) s["options"]["options"]["renderCropWindow"]["value"].setValue( imath.Box2f( imath.V2f( 0.25, 0.5 ), imath.V2f( 0.75, 1.0 ) ) ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), 160 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 479 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), 240 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 479 ) # Test Empty Crop Window s["options"]["options"]["renderCropWindow"]["value"].setValue( imath.Box2f() ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) # Since Arnold doesn't support empty regions, we default to one pixel in the corner self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), 0 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 0 ) # Apply Overscan s["options"]["options"]["renderCropWindow"]["enabled"].setValue( False ) s["options"]["options"]["overscan"]["enabled"].setValue( True ) s["options"]["options"]["overscan"]["value"].setValue( True ) s["options"]["options"]["overscanTop"]["enabled"].setValue( True ) s["options"]["options"]["overscanTop"]["value"].setValue( 0.1 ) s["options"]["options"]["overscanBottom"]["enabled"].setValue( True ) s["options"]["options"]["overscanBottom"]["value"].setValue( 0.2 ) s["options"]["options"]["overscanLeft"]["enabled"].setValue( True ) s["options"]["options"]["overscanLeft"]["value"].setValue( 0.3 ) s["options"]["options"]["overscanRight"]["enabled"].setValue( True ) s["options"]["options"]["overscanRight"]["value"].setValue( 0.4 ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) options = arnold.AiUniverseGetOptions() self.assertEqual( arnold.AiNodeGetInt( options, "xres" ), 640 ) self.assertEqual( arnold.AiNodeGetInt( options, "yres" ), 480 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_x" ), -192 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_x" ), 640 + 255 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_min_y" ), -96 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 480 + 47 )
def testScopesDontLeak(self):
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["p"]["transform"]["translate"].setValue(IECore.V3f(-0.6, -0.1, 0))
s["p1"] = GafferScene.Plane()
s["p1"]["transform"]["translate"].setValue(IECore.V3f(0.6, 0.1, 0))
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(2)
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["p"]["out"])
s["g"]["in"][1].setInput(s["p1"]["out"])
s["g"]["in"][2].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader(
self.compileShader(os.path.dirname(__file__) + "/shaders/flat.sl"))
s["s"]["parameters"]["c"].setValue(IECore.Color3f(1, 0, 0))
s["f"] = GafferScene.PathFilter()
s["f"]["paths"].setValue(IECore.StringVectorData(["/group/plane"]))
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["a"]["filter"].setInput(s["f"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlanes",
}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["options"]["renderResolution"]["value"].setValue(
IECore.V2i(512))
s["o"]["options"]["renderResolution"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output.
# we should have a red plane on the left, and a facing ratio
# shaded plane on the right, because we attached no shader to the
# second plane.
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.25, 0.5),
)
self.assertEqual(c, IECore.Color3f(1, 0, 0))
c1 = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.75, 0.5),
)
self.assertTrue(c1[0] > 0.9)
self.assertEqual(c1[0], c1[1])
self.assertEqual(c1[0], c1[2])
# adjust a shader parameter, wait, and check that the plane
# on the left changed. check that the plane on the right didn't
# change at all.
s["s"]["parameters"]["c"].setValue(IECore.Color3f(0, 1, 0))
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.25, 0.5),
)
self.assertEqual(c, IECore.Color3f(0, 1, 0))
c1 = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlanes"),
IECore.V2f(0.75, 0.5),
)
self.assertTrue(c1[0] > 0.9)
self.assertEqual(c1[0], c1[1])
self.assertEqual(c1[0], c1[2])
def __init__( self, name = "__CameraSetup" ) :
GafferScene.FilteredSceneProcessor.__init__( self, name )
# Public plugs
self["cameraGroup"] = Gaffer.StringPlug( "cameraGroup", Gaffer.Plug.Direction.In, "__TEXTUREBAKE_CAMERAS" )
self["bakeDirectory"] = Gaffer.StringPlug( "bakeDirectory", Gaffer.Plug.Direction.In, "" )
self["defaultFileName"] = Gaffer.StringPlug( "defaultFileName", Gaffer.Plug.Direction.In, "${bakeDirectory}/<AOV>/<AOV>.<UDIM>.exr" )
self["defaultResolution"] = Gaffer.IntPlug( "defaultResolution", Gaffer.Plug.Direction.In, 512 )
self["uvSet"] = Gaffer.StringPlug( "uvSet", Gaffer.Plug.Direction.In, "uv" )
self["normalOffset"] = Gaffer.FloatPlug( "normalOffset", Gaffer.Plug.Direction.In, 0.1 )
self["aovs"] = Gaffer.StringPlug( "aovs", Gaffer.Plug.Direction.In, "beauty:rgba" )
self["tasks"] = Gaffer.IntPlug( "tasks", Gaffer.Plug.Direction.In, 1 )
self["taskIndex"] = Gaffer.IntPlug( "taskIndex", Gaffer.Plug.Direction.In, 0 )
# Output
self["renderFileList"] = Gaffer.StringVectorDataPlug( "renderFileList", Gaffer.Plug.Direction.Out, defaultValue = IECore.StringVectorData() )
self["renderFileList"].setFlags( Gaffer.Plug.Flags.Serialisable, False )
# Private internal network
self["__udimQuery"] = GafferScene.UDIMQuery()
self["__udimQuery"]["in"].setInput( self["in"] )
self["__udimQuery"]["uvSet"].setInput( self["uvSet"] )
self["__udimQuery"]["attributes"].setValue( "bake:resolution bake:fileName" )
self["__udimQuery"]["filter"].setInput( self["filter"] )
self["__chunkedBakeInfo"] = Gaffer.CompoundObjectPlug( "__chunkedBakeInfo", Gaffer.Plug.Direction.In, IECore.CompoundObject() )
self["__chunkedBakeInfo"].setFlags( Gaffer.Plug.Flags.Serialisable, False )
self["__chunkExpression"] = Gaffer.Expression()
self["__chunkExpression"].setExpression( inspect.cleandoc(
"""
# Locate the next point in the list of files to bake where we can split the list into chunks without
# seperating two files that need to get combined into the same texture
def nextChunkBreak( i, l ):
while i > 0 and i < len( l ) and (
l[i - 1].get("udim") == l[i].get("udim") and
l[i - 1].get("fileName") == l[i].get("fileName") ):
i += 1
return i
rawInfo = parent["__udimQuery"]["out"]
defaultFileName = parent["defaultFileName"]
defaultResolution = parent["defaultResolution"]
listInfo = []
for udim, meshes in rawInfo.items():
for mesh, extraAttributes in meshes.items():
resolution = defaultResolution
if "bake:resolution" in extraAttributes:
resolution = extraAttributes["bake:resolution"].value
fileName = defaultFileName
if "bake:fileName" in extraAttributes:
fileName = extraAttributes["bake:fileName"].value
listInfo.append( { "udim" : int( udim ), "mesh" : mesh, "resolution" : resolution, "fileName" : fileName } )
listInfo.sort( key = lambda i: (i["fileName"], i["udim"] ) )
info = IECore.CompoundObject()
numTasks = parent["tasks"]
taskIndex = parent["taskIndex"]
chunkStart = nextChunkBreak( ( taskIndex * len( listInfo ) ) / numTasks, listInfo )
chunkEnd = nextChunkBreak( ( ( taskIndex + 1 ) * len( listInfo ) ) / numTasks, listInfo )
dupeCount = 0
prevFileName = ""
for i in listInfo[chunkStart:chunkEnd]:
o = IECore.CompoundObject()
o["mesh"] = IECore.StringData( i["mesh"] )
o["udim"] = IECore.IntData( i["udim"] )
o["resolution"] = IECore.IntData( i["resolution"] )
udimStr = str( i["udim"] )
fileName = i["fileName"].replace( "<UDIM>", udimStr )
if fileName == prevFileName:
dupeCount += 1
fileName = fileName + ".layer" + str( dupeCount )
else:
prevFileName = fileName
dupeCount = 0
o["fileName"] = IECore.StringData( fileName )
name = o["mesh"].value.replace( "/", "_" ) + "." + udimStr
info[ name ] = o
parent["__chunkedBakeInfo"] = info
fileList = []
for name, i in info.items():
fileName = i["fileName"].value
for nameAndAov in parent["aovs"].strip( " " ).split( " " ):
fileList.append( i["fileName"].value.replace( "<AOV>", nameAndAov.split(":")[0] ) )
parent["renderFileList"] = IECore.StringVectorData( fileList )
"""
), "python" )
self["__parent"] = GafferScene.Parent()
self["__parent"]["parent"].setValue( "/" )
for c in ['bound', 'transform', 'attributes', 'object', 'childNames', 'setNames', 'set']:
self["__parent"]["in"][c].setInput( self["in"][c] )
self["__outputExpression"] = Gaffer.Expression()
self["__outputExpression"].setExpression( inspect.cleandoc(
"""
import IECoreScene
# Transfer all input globals except for outputs
inGlobals = parent["in"]["globals"]
outGlobals = IECore.CompoundObject()
for key, value in inGlobals.items():
if not key.startswith( "output:" ):
outGlobals[key] = value
# Make our own outputs
info = parent["__chunkedBakeInfo"]
for cameraName, i in info.items():
params = IECore.CompoundData()
fileName = i["fileName"].value
params["camera"] = IECore.StringData( "/" + parent["cameraGroup"] + "/" + cameraName )
for nameAndAov in parent["aovs"].strip( " " ).split( " " ):
tokens = nameAndAov.split( ":" )
if len( tokens ) != 2:
raise RuntimeError( "Invalid bake aov specification: %s It should contain a : between name and data." )
( aovName, aov ) = tokens
aovFileName = fileName.replace( "<AOV>", aovName )
outGlobals["output:" + cameraName + "." + aov] = IECoreScene.Output( aovFileName, "exr", aov + " RGBA", params )
parent["__parent"]["in"]["globals"] = outGlobals
"""
), "python" )
self["__camera"] = GafferScene.Camera()
self["__camera"]["projection"].setValue( "orthographic" )
self["__cameraTweaks"] = GafferScene.CameraTweaks()
self["__cameraTweaks"]["in"].setInput( self["__camera"]["out"] )
self["__cameraTweaks"]["tweaks"]["projection"] = GafferScene.TweakPlug( "projection", "uv_camera" )
self["__cameraTweaks"]["tweaks"]["resolution"] = GafferScene.TweakPlug( "resolution", imath.V2i( 0 ) )
self["__cameraTweaks"]["tweaks"]["u_offset"] = GafferScene.TweakPlug( "u_offset", 0.0 )
self["__cameraTweaks"]["tweaks"]["v_offset"] = GafferScene.TweakPlug( "v_offset", 0.0 )
self["__cameraTweaks"]["tweaks"]["mesh"] = GafferScene.TweakPlug( "mesh", "" )
self["__cameraTweaks"]["tweaks"]["uv_set"] = GafferScene.TweakPlug( "uv_set", "" )
self["__cameraTweaks"]["tweaks"]["extend_edges"] = GafferScene.TweakPlug( "extend_edges", False )
self["__cameraTweaks"]["tweaks"]["offset"] = GafferScene.TweakPlug( "offset", 0.1 )
self["__cameraTweaks"]["tweaks"]["offset"]["value"].setInput( self["normalOffset"] )
self["__cameraTweaksFilter"] = GafferScene.PathFilter()
self["__cameraTweaksFilter"]["paths"].setValue( IECore.StringVectorData( [ '/camera' ] ) )
self["__cameraTweaks"]["filter"].setInput( self["__cameraTweaksFilter"]["out"] )
self["__collectScenes"] = GafferScene.CollectScenes()
self["__collectScenes"]["sourceRoot"].setValue( "/camera" )
self["__collectScenes"]["rootNameVariable"].setValue( "collect:cameraName" )
self["__collectScenes"]["in"].setInput( self["__cameraTweaks"]["out"] )
self["__group"] = GafferScene.Group()
self["__group"]["in"][0].setInput( self["__collectScenes"]["out"] )
self["__group"]["name"].setInput( self["cameraGroup"] )
self["__parent"]["child"].setInput( self["__group"]["out"] )
self["__collectSceneRootsExpression"] = Gaffer.Expression()
self["__collectSceneRootsExpression"].setExpression( inspect.cleandoc(
"""
info = parent["__chunkedBakeInfo"]
parent["__collectScenes"]["rootNames"] = IECore.StringVectorData( info.keys() )
"""
), "python" )
self["__cameraSetupExpression"] = Gaffer.Expression()
self["__cameraSetupExpression"].setExpression( inspect.cleandoc(
"""
cameraName = context["collect:cameraName"]
info = parent["__chunkedBakeInfo"]
i = info[cameraName]
udimOffset = i["udim"].value - 1001
parent["__cameraTweaks"]["tweaks"]["resolution"]["value"] = imath.V2i( i["resolution"].value )
parent["__cameraTweaks"]["tweaks"]["u_offset"]["value"] = -( udimOffset % 10 )
parent["__cameraTweaks"]["tweaks"]["v_offset"]["value"] = -( udimOffset / 10 )
parent["__cameraTweaks"]["tweaks"]["mesh"]["value"] = i["mesh"].value
parent["__cameraTweaks"]["tweaks"]["uv_set"]["value"] = parent["uvSet"] if parent["uvSet"] != "uv" else ""
"""
), "python" )
self["out"].setFlags( Gaffer.Plug.Flags.Serialisable, False )
self["out"].setInput( self["__parent"]["out"] )
def testAddLight(self):
s = Gaffer.ScriptNode()
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["parameters"]["lightcolor"].setValue(IECore.Color3f(1, 0, 0))
s["l"]["transform"]["translate"]["z"].setValue(1)
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["l"]["out"])
s["g"]["in"][1].setInput(s["p"]["out"])
s["g"]["in"][2].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("matte")
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0, 0))
# add a light
s["l2"] = GafferRenderMan.RenderManLight()
s["l2"].loadShader("pointlight")
s["l2"]["parameters"]["lightcolor"].setValue(IECore.Color3f(0, 1, 0))
s["l2"]["transform"]["translate"]["z"].setValue(1)
s["g"]["in"][3].setInput(s["l2"]["out"])
# give it time to update, and check the output
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 1, 0))
def testLightLinkingAfterParameterUpdates(self):
s = Gaffer.ScriptNode()
s["catalogue"] = GafferImage.Catalogue()
s["s"] = GafferScene.Sphere()
s["PathFilter"] = GafferScene.PathFilter("PathFilter")
s["PathFilter"]["paths"].setValue(IECore.StringVectorData(['/sphere']))
s["ShaderAssignment"] = GafferScene.ShaderAssignment(
"ShaderAssignment")
s["ShaderAssignment"]["in"].setInput(s["s"]["out"])
s["ShaderAssignment"]["filter"].setInput(s["PathFilter"]["out"])
s["lambert"], _ = self._createMatteShader()
s["ShaderAssignment"]["shader"].setInput(s["lambert"]["out"])
s["StandardAttributes"] = GafferScene.StandardAttributes(
"StandardAttributes")
s["StandardAttributes"]["attributes"]["linkedLights"][
"enabled"].setValue(True)
s["StandardAttributes"]["attributes"]["linkedLights"][
"value"].setValue("defaultLights")
s["StandardAttributes"]["filter"].setInput(s["PathFilter"]["out"])
s["StandardAttributes"]["in"].setInput(s["ShaderAssignment"]["out"])
s["Light"] = GafferArnold.ArnoldLight("skydome_light")
s["Light"].loadShader("skydome_light")
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(2)
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["StandardAttributes"]["out"])
s["group"]["in"][1].setInput(s["Light"]["out"])
s["group"]["in"][2].setInput(s["c"]["out"])
s["o"] = GafferScene.Outputs()
s["o"].addOutput(
"beauty",
IECoreScene.Output(
"test", "ieDisplay", "rgba", {
"driverType":
"ClientDisplayDriver",
"displayHost":
"localhost",
"displayPort":
str(s['catalogue'].displayDriverServer().portNumber()),
"remoteDisplayType":
"GafferImage::GafferDisplayDriver",
}))
s["o"]["in"].setInput(s["group"]["out"])
s["so"] = GafferScene.StandardOptions()
s["so"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["so"]["options"]["renderCamera"]["enabled"].setValue(True)
s["so"]["in"].setInput(s["o"]["out"])
s["r"] = self._createInteractiveRender()
s["r"]["in"].setInput(s["so"]["out"])
# Start rendering and make sure the light is linked to the sphere
s["r"]["state"].setValue(s["r"].State.Running)
self.uiThreadCallHandler.waitFor(1.0)
self.assertAlmostEqual(self._color4fAtUV(s["catalogue"],
imath.V2f(0.5)).r,
1,
delta=0.01)
# Change a value on the light. The light should still be linked to the sphere
# and we should get the same result as before.
s["Light"]['parameters']['shadow_density'].setValue(0.0)
self.uiThreadCallHandler.waitFor(1.0)
self.assertAlmostEqual(self._color4fAtUV(s["catalogue"],
imath.V2f(0.5)).r,
1,
delta=0.01)
s["r"]["state"].setValue(s["r"].State.Stopped)
def testHideLight(self):
s = Gaffer.ScriptNode()
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["transform"]["translate"]["z"].setValue(1)
s["v"] = GafferScene.StandardAttributes()
s["v"]["attributes"]["visibility"]["enabled"].setValue(True)
s["v"]["in"].setInput(s["l"]["out"])
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["v"]["out"])
s["g"]["in"][1].setInput(s["p"]["out"])
s["g"]["in"][2].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("matte")
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertNotEqual(c[0], 0.0)
# remove the light by hiding it
s["v"]["attributes"]["visibility"]["value"].setValue(False)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c[0], 0.0)
# put the light back by showing it
s["v"]["attributes"]["visibility"]["value"].setValue(True)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertNotEqual(c[0], 0.0)
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 testLights(self):
s = Gaffer.ScriptNode()
s["l"] = GafferRenderMan.RenderManLight()
s["l"].loadShader("pointlight")
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
s["l"]["transform"]["translate"]["z"].setValue(1)
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["l"]["out"])
s["g"]["in"][1].setInput(s["p"]["out"])
s["g"]["in"][2].setInput(s["c"]["out"])
s["s"] = GafferRenderMan.RenderManShader()
s["s"].loadShader("matte")
s["a"] = GafferScene.ShaderAssignment()
s["a"]["in"].setInput(s["g"]["out"])
s["a"]["shader"].setInput(s["s"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
s["d"]["in"].setInput(s["a"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0.5, 0.25))
# adjust a parameter, give it time to update, and check the output
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(0.25, 0.5, 1))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
# pause it, adjust a parameter, wait, and check that nothing changed
s["r"]["state"].setValue(s["r"].State.Paused)
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
# unpause it, wait, and check that the update happened
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0.5, 0.25))
# turn off light updates, adjust a parameter, wait, and check nothing happened
s["r"]["updateLights"].setValue(False)
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(0.25, 0.5, 1))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[0], IECore.Color3f(1, 0.5, 0.25))
# turn light updates back on and check that it updates
s["r"]["updateLights"].setValue(True)
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
# stop the render, tweak a parameter and check that nothing happened
s["r"]["state"].setValue(s["r"].State.Stopped)
s["l"]["parameters"]["lightcolor"].setValue(
IECore.Color3f(1, 0.5, 0.25))
time.sleep(1)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertEqual(c / c[2], IECore.Color3f(0.25, 0.5, 1))
def testCameraMotionBlur(self):
s = Gaffer.ScriptNode()
s["camera"] = GafferScene.Camera()
s["attributes"] = GafferScene.StandardAttributes()
s["attributes"]["in"].setInput(s["camera"]["out"])
s["options"] = GafferScene.StandardOptions()
s["options"]["in"].setInput(s["attributes"]["out"])
s["options"]["options"]["renderCamera"]["enabled"].setValue(True)
s["options"]["options"]["renderCamera"]["value"].setValue("/camera")
s["render"] = GafferRenderMan.RenderManRender()
s["render"]["in"].setInput(s["options"]["out"])
s["render"]["mode"].setValue("generate")
s["render"]["ribFileName"].setValue("/tmp/test.rib")
s["fileName"].setValue("/tmp/test.gfr")
s.save()
s["render"].execute([Gaffer.Context.current()])
self.assertTrue(os.path.exists("/tmp/test.rib"))
# camera motion off, we should have no motion statements
r = "".join(file("/tmp/test.rib").readlines())
self.failIf("MotionBegin" in r)
# camera motion on, we should have no motion statements
s["options"]["options"]["cameraBlur"]["enabled"].setValue(True)
s["options"]["options"]["cameraBlur"]["value"].setValue(True)
s["render"].execute([Gaffer.Context.current()])
r = "".join(file("/tmp/test.rib").readlines())
self.failUnless("MotionBegin" in r)
# motion disabled on camera object, we should have no motion statements
# even though motion blur is enabled in the globals.
s["attributes"]["attributes"]["transformBlur"]["enabled"].setValue(
True)
s["attributes"]["attributes"]["transformBlur"]["value"].setValue(False)
s["render"].execute([Gaffer.Context.current()])
r = "".join(file("/tmp/test.rib").readlines())
self.failIf("MotionBegin" in r)
# motion enabled on camera object, with extra samples specified. we should
# have a motion statement with multiple segments
s["attributes"]["attributes"]["transformBlur"]["value"].setValue(True)
s["attributes"]["attributes"]["transformBlurSegments"][
"enabled"].setValue(True)
s["attributes"]["attributes"]["transformBlurSegments"][
"value"].setValue(5)
s["render"].execute([Gaffer.Context.current()])
def motionTimes(ribFileName):
for line in file(ribFileName).readlines():
if "MotionBegin" in line:
times = line.partition("[")[2].partition("]")[0]
times = times.strip().split()
return [float(t) for t in times]
return []
self.assertEqual(len(motionTimes("/tmp/test.rib")), 6)
# different shutter times
s["attributes"]["attributes"]["transformBlurSegments"][
"enabled"].setValue(False)
s["options"]["options"]["shutter"]["enabled"].setValue(True)
s["render"].execute([Gaffer.Context.current()])
self.assertEqual(motionTimes("/tmp/test.rib"), [0.75, 1.25])
s["options"]["options"]["shutter"]["value"].setValue(
IECore.V2f(-0.1, 0.3))
s["render"].execute([Gaffer.Context.current()])
self.assertEqual(motionTimes("/tmp/test.rib"), [0.9, 1.3])
def testMoveCamera(self):
s = Gaffer.ScriptNode()
s["p"] = GafferScene.Plane()
s["c"] = GafferScene.Camera()
s["c"]["transform"]["translate"]["z"].setValue(1)
s["g"] = GafferScene.Group()
s["g"]["in"][0].setInput(s["p"]["out"])
s["g"]["in"][1].setInput(s["c"]["out"])
s["d"] = GafferScene.Outputs()
s["d"].addOutput(
"beauty",
IECore.Display(
"test", "ieDisplay", "rgba", {
"quantize": IECore.FloatVectorData([0, 0, 0, 0]),
"driverType": "ImageDisplayDriver",
"handle": "myLovelyPlane",
}))
s["d"]["in"].setInput(s["g"]["out"])
s["o"] = GafferScene.StandardOptions()
s["o"]["options"]["renderCamera"]["value"].setValue("/group/camera")
s["o"]["options"]["renderCamera"]["enabled"].setValue(True)
s["o"]["in"].setInput(s["d"]["out"])
s["r"] = GafferRenderMan.InteractiveRenderManRender()
s["r"]["in"].setInput(s["o"]["out"])
# start a render, give it time to finish, and check the output
s["r"]["state"].setValue(s["r"].State.Running)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertAlmostEqual(c[1], 1, delta=0.001)
# move the camera so it can't see the plane, and check the output
s["c"]["transform"]["translate"]["x"].setValue(2)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertAlmostEqual(c[0], 0)
# move the camera back and recheck
s["c"]["transform"]["translate"]["x"].setValue(0)
time.sleep(2)
c = self.__colorAtUV(
IECore.ImageDisplayDriver.storedImage("myLovelyPlane"),
IECore.V2f(0.5),
)
self.assertAlmostEqual(c[1], 1, delta=0.001)
viewer.view().viewportGadget().getPrimaryChild().waitForCompletion()
GafferUI.WidgetAlgo.grab(widget=scriptWindow,
imagePath="images/mainHeadAndLeftLegExpanded.png")
# GafferBot head and both legs in Viewer
paths = IECore.PathMatcher(["/GAFFERBOT/C_torso_GRP/L_legUpper_GRP"])
GafferSceneUI.ContextAlgo.expand(script.context(), paths)
GafferSceneUI.ContextAlgo.expandDescendants(script.context(), paths,
readerNode["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(script.context(), paths)
viewer.view().viewportGadget().getPrimaryChild().waitForCompletion()
GafferUI.WidgetAlgo.grab(widget=viewer,
imagePath="images/viewerHeadAndLegsExpanded.png")
# Camera and SceneReader node in main window
script["Camera"] = GafferScene.Camera()
cameraNode = script["Camera"]
script.selection().clear()
script.selection().add(cameraNode)
script.setFocus(cameraNode)
# Approximate the default viewport position
viewer.view().viewportGadget().frame(
imath.Box3f(imath.V3f(0, -1.75, 0), imath.V3f(5, 5, 5)))
viewer.view().viewportGadget().getPrimaryChild().waitForCompletion()
GafferUI.WidgetAlgo.grab(widget=scriptWindow,
imagePath="images/mainCameraNode.png")
# Grouped nodes in Gaffer
script["Group"] = GafferScene.Group()
groupNode = script["Group"]
groupNode["in"][0].setInput(readerNode["out"])
def testEditResolution(self):
s = Gaffer.ScriptNode()
s["sphere"] = GafferScene.Sphere()
s["camera"] = GafferScene.Camera()
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["sphere"]["out"])
s["group"]["in"][1].setInput(s["camera"]["out"])
s["outputs"] = GafferScene.Outputs()
s["outputs"].addOutput(
"beauty",
IECore.Display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "myLovelySphere",
}))
s["outputs"]["in"].setInput(s["group"]["out"])
s["options"] = GafferScene.StandardOptions()
s["options"]["in"].setInput(s["outputs"]["out"])
s["options"]["options"]["renderCamera"]["enabled"].setValue(True)
s["r"] = self._createInteractiveRender()
s["r"]["in"].setInput(s["options"]["out"])
s["r"]["state"].setValue(s["r"].State.Running)
for withDefaultCamera in (True, False):
s["options"]["options"]["renderCamera"]["value"].setValue(
"" if withDefaultCamera else "/group/camera")
time.sleep(0.5)
# Use the default resolution to start with
self.assertEqual(
IECore.ImageDisplayDriver.storedImage(
"myLovelySphere").displayWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
# Now specify a resolution
s["options"]["options"]["renderResolution"]["enabled"].setValue(
True)
s["options"]["options"]["renderResolution"]["value"].setValue(
IECore.V2i(200, 100))
time.sleep(0.5)
self.assertEqual(
IECore.ImageDisplayDriver.storedImage(
"myLovelySphere").displayWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(199, 99)))
# And specify another resolution
s["options"]["options"]["renderResolution"]["value"].setValue(
IECore.V2i(300, 100))
time.sleep(0.5)
self.assertEqual(
IECore.ImageDisplayDriver.storedImage(
"myLovelySphere").displayWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(299, 99)))
# And back to the default
s["options"]["options"]["renderResolution"]["enabled"].setValue(
False)
time.sleep(0.5)
self.assertEqual(
IECore.ImageDisplayDriver.storedImage(
"myLovelySphere").displayWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
