def testDefaultCamera(self):
# render a plane at z==0 and check we can't see it with the default camera
m = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-0.1), IECore.V2f(0.1)))
r = IECoreArnold.Renderer()
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
r.setOption("ai:AA_samples", IECore.IntData(3))
with IECore.WorldBlock(r):
m.render(r)
image = IECore.ImageDisplayDriver.removeStoredImage("test")
self.assertEqual(image.dataWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
e = IECore.PrimitiveEvaluator.create(image)
result = e.createResult()
e.pointAtUV(IECore.V2f(0.5, 0.5), result)
self.failUnless(result.floatPrimVar(image["A"]) < 0.5)
# move the plane back a touch and check we can see it with the default camera
del r # must destroy the existing renderer before making a new one
r = IECoreArnold.Renderer()
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
r.setOption("ai:AA_samples", IECore.IntData(3))
with IECore.WorldBlock(r):
with IECore.TransformBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -1)))
m.render(r)
image = IECore.ImageDisplayDriver.removeStoredImage("test")
self.assertEqual(image.dataWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
e = IECore.PrimitiveEvaluator.create(image)
result = e.createResult()
e.pointAtUV(IECore.V2f(0.5, 0.5), result)
self.failUnless(result.floatPrimVar(image["A"]) > 0.9)
# move the camera back a touch and check we can see the plane at z==0
del r # must destroy the existing renderer before making a new one
r = IECoreArnold.Renderer()
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
r.setOption("ai:AA_samples", IECore.IntData(3))
with IECore.TransformBlock(r):
r.concatTransform(IECore.M44f.createTranslated(IECore.V3f(0, 0,
1)))
r.camera("main", {})
with IECore.WorldBlock(r):
m.render(r)
image = IECore.ImageDisplayDriver.removeStoredImage("test")
self.assertEqual(image.dataWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
e = IECore.PrimitiveEvaluator.create(image)
result = e.createResult()
e.pointAtUV(IECore.V2f(0.5, 0.5), result)
self.failUnless(result.floatPrimVar(image["A"]) > 0.9)
def testCameraAspectRatio(self):
r = IECoreArnold.Renderer()
r.camera(
"main", {
"resolution": IECore.V2i(640, 480),
"screenWindow": IECore.Box2f(IECore.V2f(0), IECore.V2f(
640, 480))
})
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
with IECore.WorldBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
r.shader("surface", "utility", {
"shading_mode": "flat",
"color": IECore.Color3f(1, 0, 0)
})
IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(2), IECore.V2f(638, 478))).render(r)
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -1)))
r.shader("surface", "utility", {
"shade_mode": "flat",
"color": IECore.Color3f(0, 1, 0)
})
IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(0), IECore.V2f(640, 480))).render(r)
image = IECore.ImageDisplayDriver.removeStoredImage("test")
self.failUnless(image is not None)
e = IECore.PrimitiveEvaluator.create(image)
result = e.createResult()
r = e.R()
g = e.G()
edges = [
IECore.V2i(0),
IECore.V2i(320, 0),
IECore.V2i(639, 0),
IECore.V2i(639, 240),
IECore.V2i(639, 479),
IECore.V2i(320, 479),
IECore.V2i(0, 479),
IECore.V2i(0, 240),
]
for point in edges:
self.failUnless(e.pointAtPixel(point, result))
self.failUnless(result.floatPrimVar(r) < 0.1)
self.failUnless(result.floatPrimVar(g) > 0.8)
innerEdges = [
IECore.V2i(3, 3),
IECore.V2i(320, 3),
IECore.V2i(637, 3),
IECore.V2i(636, 240),
IECore.V2i(636, 477),
IECore.V2i(320, 477),
IECore.V2i(3, 477),
IECore.V2i(3, 240),
]
for point in innerEdges:
self.failUnless(e.pointAtPixel(point, result))
self.failUnless(result.floatPrimVar(r) > 0.8)
self.failUnless(result.floatPrimVar(g) < 0.1)
def createBlock(writable):
with IECoreArnold.UniverseBlock(writable):
self.failUnless(arnold.AiUniverseIsActive())
def __forceArnoldRestart(self):
with IECoreArnold.UniverseBlock(writable=True):
pass
def testNPrimitiveVariable(self):
c = IECoreScene.CurvesPrimitive(IECore.IntVectorData([4]),
IECore.CubicBasisf.catmullRom())
c["P"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(x, 0, 0) for x in range(0, 4)]))
with IECoreArnold.UniverseBlock(writable=True) as universe:
# No N - should be a ribbon
n = IECoreArnold.NodeAlgo.convert(c, universe, "testCurve")
self.assertEqual(arnold.AiNodeGetStr(n, "mode"), "ribbon")
self.assertEqual(
arnold.AiArrayGetNumElements(
arnold.AiNodeGetArray(n, "orientations").contents), 0)
# N - should be oriented
c["N"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([
imath.V3f(0, math.sin(x), math.cos(x))
for x in range(0, 4)
]))
n = IECoreArnold.NodeAlgo.convert(c, universe, "testCurve")
self.assertEqual(arnold.AiNodeGetStr(n, "mode"), "oriented")
orientations = arnold.AiNodeGetArray(n, "orientations")
self.assertEqual(
arnold.AiArrayGetNumElements(orientations.contents), 4)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetVec(orientations, i),
arnold.AtVector(0, math.sin(i), math.cos(i)))
# Motion blurred N - should be oriented and deforming
c2 = c.copy()
c2["N"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([
imath.V3f(0, math.sin(x + 0.2), math.cos(x + 0.2))
for x in range(0, 4)
]))
n = IECoreArnold.NodeAlgo.convert([c, c2], 0.0, 1.0, universe,
"testCurve")
self.assertEqual(arnold.AiNodeGetStr(n, "mode"), "oriented")
orientations = arnold.AiNodeGetArray(n, "orientations")
self.assertEqual(
arnold.AiArrayGetNumElements(orientations.contents), 4)
self.assertEqual(arnold.AiArrayGetNumKeys(orientations.contents),
2)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetVec(orientations, i),
arnold.AtVector(0, math.sin(i), math.cos(i)))
self.assertEqual(
arnold.AiArrayGetVec(orientations, i + 4),
arnold.AtVector(0, math.sin(i + 0.2), math.cos(i + 0.2)))
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" ), 479 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 479 ) # 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" ), -48 ) self.assertEqual( arnold.AiNodeGetInt( options, "region_max_y" ), 480 + 95 )
def testDefaultCamera(self):
# render a plane at z==0 and check we can't see it with the default camera
m = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-0.1), IECore.V2f(0.1)))
r = IECoreArnold.Renderer()
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
r.setOption("ai:AA_samples", IECore.IntData(3))
with IECore.WorldBlock(r):
m.render(r)
image = IECoreImage.ImageDisplayDriver.removeStoredImage("test")
self.assertEqual(image.dataWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
dimensions = image.dataWindow.size() + IECore.V2i(1)
index = dimensions.x * int(dimensions.y * 0.5) + int(
dimensions.x * 0.5)
self.failUnless(image["A"][index] < 0.5)
# move the plane back a touch and check we can see it with the default camera
del r # must destroy the existing renderer before making a new one
r = IECoreArnold.Renderer()
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
r.setOption("ai:AA_samples", IECore.IntData(3))
with IECore.WorldBlock(r):
with IECore.TransformBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -1)))
m.render(r)
image = IECoreImage.ImageDisplayDriver.removeStoredImage("test")
self.assertEqual(image.dataWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
dimensions = image.dataWindow.size() + IECore.V2i(1)
index = dimensions.x * int(dimensions.y * 0.5) + int(
dimensions.x * 0.5)
self.failUnless(image["A"][index] > 0.9)
# move the camera back a touch and check we can see the plane at z==0
del r # must destroy the existing renderer before making a new one
r = IECoreArnold.Renderer()
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
r.setOption("ai:AA_samples", IECore.IntData(3))
with IECore.TransformBlock(r):
r.concatTransform(IECore.M44f.createTranslated(IECore.V3f(0, 0,
1)))
r.camera("main", {})
with IECore.WorldBlock(r):
m.render(r)
image = IECoreImage.ImageDisplayDriver.removeStoredImage("test")
self.assertEqual(image.dataWindow,
IECore.Box2i(IECore.V2i(0), IECore.V2i(639, 479)))
dimensions = image.dataWindow.size() + IECore.V2i(1)
index = dimensions.x * int(dimensions.y * 0.5) + int(
dimensions.x * 0.5)
self.failUnless(image["A"][index] > 0.9)
# nice looking names
__metadata[paramPath]["label"] = " ".join(
[i.capitalize() for i in paramName.split("_")])
# NodeGraph visibility from Gaffer-specific metadata
visible = __aiMetadataGetBool(
nodeEntry, None, "gaffer.nodeGraphLayout.defaultVisibility")
visible = __aiMetadataGetBool(nodeEntry, paramName,
"gaffer.nodeGraphLayout.visible",
visible)
if visible is not None:
__metadata[paramPath]["noduleLayout:visible"] = visible
with IECoreArnold.UniverseBlock(writable=False):
nodeIt = arnold.AiUniverseGetNodeEntryIterator(arnold.AI_NODE_SHADER
| arnold.AI_NODE_LIGHT)
while not arnold.AiNodeEntryIteratorFinished(nodeIt):
__translateNodeMetadata(arnold.AiNodeEntryIteratorGetNext(nodeIt))
##########################################################################
# Gaffer Metadata queries. These are implemented using the preconstructed
# registry above.
##########################################################################
def __nodeDescription(node):
def createBlock(writable):
with IECoreArnold.UniverseBlock(writable):
self.assertTrue(arnold.AiUniverseIsActive())
def appendShaders(menuDefinition, prefix="/Arnold"):
MenuItem = collections.namedtuple("MenuItem", ["menuPath", "nodeCreator"])
# Build a list of menu items we want to create.
categorisedMenuItems = []
uncategorisedMenuItems = []
with IECoreArnold.UniverseBlock(writable=False):
it = arnold.AiUniverseGetNodeEntryIterator(arnold.AI_NODE_SHADER
| arnold.AI_NODE_LIGHT)
while not arnold.AiNodeEntryIteratorFinished(it):
nodeEntry = arnold.AiNodeEntryIteratorGetNext(it)
shaderName = arnold.AiNodeEntryGetName(nodeEntry)
displayName = " ".join(
[IECore.CamelCase.toSpaced(x) for x in shaderName.split("_")])
category = __aiMetadataGetStr(nodeEntry, "",
"gaffer.nodeMenu.category")
if category == "":
continue
if arnold.AiNodeEntryGetType(nodeEntry) == arnold.AI_NODE_SHADER:
menuPath = "Shader"
nodeCreator = functools.partial(__shaderCreator, shaderName,
GafferArnold.ArnoldShader)
else:
menuPath = "Light"
if shaderName != "mesh_light":
nodeCreator = functools.partial(__shaderCreator,
shaderName,
GafferArnold.ArnoldLight)
else:
nodeCreator = GafferArnold.ArnoldMeshLight
if category:
menuPath += "/" + category.strip("/")
menuPath += "/" + displayName
if category:
categorisedMenuItems.append(MenuItem(menuPath, nodeCreator))
else:
uncategorisedMenuItems.append(MenuItem(menuPath, nodeCreator))
arnold.AiNodeEntryIteratorDestroy(it)
# Tidy up uncategorised shaders into a submenu if necessary.
rootsWithCategories = set(
[m.menuPath.partition("/")[0] for m in categorisedMenuItems])
for i, menuItem in enumerate(uncategorisedMenuItems):
s = menuItem.menuPath.split("/")
if s[0] in rootsWithCategories:
uncategorisedMenuItems[i] = MenuItem(
"/".join([s[0], "Other", s[1]]), menuItem.nodeCreator)
# Create the actual menu items.
for menuItem in categorisedMenuItems + uncategorisedMenuItems:
menuDefinition.append(
prefix + "/" + menuItem.menuPath, {
"command":
GafferUI.NodeMenu.nodeCreatorWrapper(menuItem.nodeCreator),
"searchText":
"ai" + menuItem.menuPath.rpartition("/")[2].replace(" ", ""),
})
def testTransformMotion(self):
s = Gaffer.ScriptNode()
s["plane"] = GafferScene.Plane()
s["sphere"] = GafferScene.Sphere()
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["plane"]["out"])
s["group"]["in"][1].setInput(s["sphere"]["out"])
s["expression"] = Gaffer.Expression()
s["expression"].setExpression(
inspect.cleandoc("""
parent["plane"]["transform"]["translate"]["x"] = context.getFrame()
parent["sphere"]["transform"]["translate"]["y"] = context.getFrame() * 2
parent["group"]["transform"]["translate"]["z"] = context.getFrame() - 1
"""))
s["planeFilter"] = GafferScene.PathFilter()
s["planeFilter"]["paths"].setValue(
IECore.StringVectorData(["/group/plane"]))
s["attributes"] = GafferScene.StandardAttributes()
s["attributes"]["in"].setInput(s["group"]["out"])
s["attributes"]["filter"].setInput(s["planeFilter"]["out"])
s["attributes"]["attributes"]["transformBlur"]["enabled"].setValue(
True)
s["attributes"]["attributes"]["transformBlur"]["value"].setValue(False)
s["options"] = GafferScene.StandardOptions()
s["options"]["in"].setInput(s["attributes"]["out"])
s["options"]["options"]["transformBlur"]["enabled"].setValue(True)
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")
# No motion blur
s["options"]["options"]["transformBlur"]["value"].setValue(False)
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
sphere = arnold.AiNodeLookUpByName("/group/sphere")
sphereTimes = arnold.AiNodeGetArray(sphere,
"transform_time_samples")
sphereMatrix = arnold.AtMatrix()
arnold.AiNodeGetMatrix(sphere, "matrix", sphereMatrix)
plane = arnold.AiNodeLookUpByName("/group/plane")
planeTimes = arnold.AiNodeGetArray(plane, "transform_time_samples")
planeMatrix = arnold.AtMatrix()
arnold.AiNodeGetMatrix(plane, "matrix", planeMatrix)
expectedSphereMatrix = arnold.AtMatrix()
arnold.AiM4Translation(expectedSphereMatrix,
arnold.AtVector(0, 2, 0))
expectedPlaneMatrix = arnold.AtMatrix()
arnold.AiM4Translation(expectedPlaneMatrix,
arnold.AtVector(1, 0, 0))
self.__assertStructsEqual(sphereMatrix, expectedSphereMatrix)
self.__assertStructsEqual(planeMatrix, expectedPlaneMatrix)
# Motion blur
s["options"]["options"]["transformBlur"]["value"].setValue(True)
s["render"]["task"].execute()
with IECoreArnold.UniverseBlock(writable=True):
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
sphere = arnold.AiNodeLookUpByName("/group/sphere")
sphereTimes = arnold.AiNodeGetArray(sphere,
"transform_time_samples")
sphereMatrices = arnold.AiNodeGetArray(sphere, "matrix")
plane = arnold.AiNodeLookUpByName("/group/plane")
planeTimes = arnold.AiNodeGetArray(plane, "transform_time_samples")
planeMatrices = arnold.AiNodeGetArray(plane, "matrix")
self.assertEqual(sphereTimes.contents.nelements, 2)
self.assertEqual(sphereTimes.contents.nkeys, 1)
self.assertEqual(sphereMatrices.contents.nelements, 1)
self.assertEqual(sphereMatrices.contents.nkeys, 2)
self.assertEqual(planeTimes.contents.nelements, 2)
self.assertEqual(planeTimes.contents.nkeys, 1)
self.assertEqual(planeMatrices.contents.nelements, 1)
self.assertEqual(planeMatrices.contents.nkeys, 2)
for i in range(0, 2):
frame = 0.75 + 0.5 * i
self.assertEqual(arnold.AiArrayGetFlt(sphereTimes, i), frame)
self.assertEqual(arnold.AiArrayGetFlt(planeTimes, i), frame)
sphereMatrix = arnold.AtMatrix()
arnold.AiArrayGetMtx(sphereMatrices, i, sphereMatrix)
expectedSphereMatrix = arnold.AtMatrix()
arnold.AiM4Translation(
expectedSphereMatrix,
arnold.AtVector(0, frame * 2, frame - 1))
planeMatrix = arnold.AtMatrix()
arnold.AiArrayGetMtx(planeMatrices, i, planeMatrix)
expectedPlaneMatrix = arnold.AtMatrix()
arnold.AiM4Translation(expectedPlaneMatrix,
arnold.AtVector(1, 0, frame - 1))
self.__assertStructsEqual(sphereMatrix, expectedSphereMatrix)
self.__assertStructsEqual(planeMatrix, expectedPlaneMatrix)
def testOldRandomCamera(self):
random.seed(42)
with IECoreArnold.UniverseBlock(writable=True):
for i in range(40):
resolution = imath.V2i(random.randint(10, 1000),
random.randint(10, 1000))
pixelAspectRatio = random.uniform(0.5, 2)
screenWindow = imath.Box2f(
imath.V2f(-random.uniform(0, 2), -random.uniform(0, 2)),
imath.V2f(random.uniform(0, 2), random.uniform(0, 2)))
screenWindowAspectScale = imath.V2f(
1.0, (screenWindow.size()[0] / screenWindow.size()[1]) *
(resolution[1] / float(resolution[0])) / pixelAspectRatio)
screenWindow.setMin(screenWindow.min() *
screenWindowAspectScale)
screenWindow.setMax(screenWindow.max() *
screenWindowAspectScale)
c = IECoreScene.Camera(
parameters={
"projection":
"orthographic"
if random.random() > 0.5 else "perspective",
"projection:fov":
random.uniform(1, 100),
"clippingPlanes":
imath.V2f(random.uniform(0.001, 100)) +
imath.V2f(0, random.uniform(0, 1000)),
"resolution":
resolution,
"pixelAspectRatio":
pixelAspectRatio
})
if i < 20:
c.parameters()["screenWindow"] = screenWindow
n = IECoreArnold.NodeAlgo.convert(c, "testCamera")
arnoldType = "persp_camera"
if c.parameters()["projection"].value == "orthographic":
arnoldType = "ortho_camera"
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n)),
arnoldType)
cortexClip = c.parameters()["clippingPlanes"].value
self.assertEqual(arnold.AiNodeGetFlt(n, "near_clip"),
cortexClip[0])
self.assertEqual(arnold.AiNodeGetFlt(n, "far_clip"),
cortexClip[1])
resolution = c.parameters()["resolution"].value
aspect = c.parameters(
)["pixelAspectRatio"].value * resolution.x / float(
resolution.y)
if "screenWindow" in c.parameters():
cortexWindow = c.parameters()["screenWindow"].value
else:
if aspect > 1.0:
cortexWindow = imath.Box2f(imath.V2f(-aspect, -1),
imath.V2f(aspect, 1))
else:
cortexWindow = imath.Box2f(imath.V2f(-1, -1 / aspect),
imath.V2f(1, 1 / aspect))
if c.parameters()["projection"].value != "orthographic":
windowScale = math.tan(
math.radians(0.5 * arnold.AiNodeGetFlt(n, "fov")))
cortexWindowScale = math.tan(
math.radians(0.5 *
c.parameters()["projection:fov"].value))
else:
windowScale = 1.0
cortexWindowScale = 1.0
self.assertAlmostEqual(
windowScale *
arnold.AiNodeGetVec2(n, "screen_window_min").x,
cortexWindowScale * cortexWindow.min()[0],
places=4)
self.assertAlmostEqual(
windowScale *
arnold.AiNodeGetVec2(n, "screen_window_min").y,
cortexWindowScale * cortexWindow.min()[1] * aspect,
places=4)
self.assertAlmostEqual(
windowScale *
arnold.AiNodeGetVec2(n, "screen_window_max").x,
cortexWindowScale * cortexWindow.max()[0],
places=4)
self.assertAlmostEqual(
windowScale *
arnold.AiNodeGetVec2(n, "screen_window_max").y,
cortexWindowScale * cortexWindow.max()[1] * aspect,
places=4)
if c.parameters()["projection"].value == "perspective":
self.assertAlmostEqual(
arnold.AiNodeGetVec2(n, "screen_window_max").x -
arnold.AiNodeGetVec2(n, "screen_window_min").x,
2.0,
places=6)
self.assertAlmostEqual(
arnold.AiNodeGetVec2(n, "screen_window_max").y -
arnold.AiNodeGetVec2(n, "screen_window_min").y,
2.0,
places=6)
def testConvertAnimatedParameters( self ) :
with IECoreArnold.UniverseBlock( writable = True ) as universe :
samples = []
for i in range( 0, 2 ) :
camera = IECoreScene.Camera()
camera.setProjection( "perspective" )
camera.setFocalLengthFromFieldOfView( 45 * ( i + 1 ) )
camera.setAperture( imath.V2f( 10, 10 + i ) )
camera.setFStop( i + 1 )
camera.setFocusDistance( i + 100 )
samples.append( camera )
animatedNode = IECoreArnold.NodeAlgo.convert( samples, 1.0, 2.0, universe, "samples" )
nodes = [ IECoreArnold.NodeAlgo.convert( samples[i], universe, "sample{}".format( i ) ) for i, sample in enumerate( samples ) ]
self.assertEqual( arnold.AiNodeGetFlt( animatedNode, "motion_start" ), 1.0 )
self.assertEqual( arnold.AiNodeGetFlt( animatedNode, "motion_start" ), 1.0 )
for i, node in enumerate( nodes ) :
animatedScreenWindowMin = arnold.AiArrayGetVec2(
arnold.AiNodeGetArray( animatedNode, "screen_window_min" ), i
)
animatedScreenWindowMax = arnold.AiArrayGetVec2(
arnold.AiNodeGetArray( animatedNode, "screen_window_max" ), i
)
self.assertEqual( animatedScreenWindowMin.x, arnold.AiNodeGetVec2( node, "screen_window_min" ).x )
self.assertEqual( animatedScreenWindowMin.y, arnold.AiNodeGetVec2( node, "screen_window_min" ).y )
self.assertEqual( animatedScreenWindowMax.x, arnold.AiNodeGetVec2( node, "screen_window_max" ).x )
self.assertEqual( animatedScreenWindowMax.y, arnold.AiNodeGetVec2( node, "screen_window_max" ).y )
self.assertEqual(
arnold.AiArrayGetFlt(
arnold.AiNodeGetArray( animatedNode, "fov" ), i
),
arnold.AiNodeGetFlt( node, "fov" )
)
self.assertEqual(
arnold.AiArrayGetFlt(
arnold.AiNodeGetArray( animatedNode, "aperture_size" ), i
),
arnold.AiNodeGetFlt( node, "aperture_size" )
)
self.assertEqual(
arnold.AiArrayGetFlt(
arnold.AiNodeGetArray( animatedNode, "focus_distance" ), i
),
arnold.AiNodeGetFlt( node, "focus_distance" )
)
for parameter in [
"screen_window_min",
"screen_window_max",
"fov",
"aperture_size",
"focus_distance",
] :
array = arnold.AiNodeGetArray( animatedNode, "fov" )
self.assertEqual( arnold.AiArrayGetNumElements( array ), 1 )
self.assertEqual( arnold.AiArrayGetNumKeys( array ), 2 )
def testTypeId(self):
self.assertEqual(IECoreArnold.Renderer().typeId(),
IECoreArnold.Renderer.staticTypeId())
self.assertNotEqual(IECoreArnold.Renderer.staticTypeId(),
IECore.Renderer.staticTypeId())
def testCameraAspectRatio(self):
r = IECoreArnold.Renderer()
r.camera(
"main", {
"resolution": IECore.V2i(640, 480),
"screenWindow": IECore.Box2f(IECore.V2f(0), IECore.V2f(
640, 480))
})
r.display("test", "ieDisplay", "rgba", {
"driverType": "ImageDisplayDriver",
"handle": "test"
})
with IECore.WorldBlock(r):
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -5)))
r.shader("surface", "utility", {
"shading_mode": "flat",
"color": IECore.Color3f(1, 0, 0)
})
IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(2), IECore.V2f(638, 478))).render(r)
r.concatTransform(
IECore.M44f.createTranslated(IECore.V3f(0, 0, -1)))
r.shader("surface", "utility", {
"shade_mode": "flat",
"color": IECore.Color3f(0, 1, 0)
})
IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(0), IECore.V2f(640, 480))).render(r)
image = IECoreImage.ImageDisplayDriver.removeStoredImage("test")
self.failUnless(image is not None)
dimensions = image.dataWindow.size() + IECore.V2i(1)
edges = [
IECore.V2i(0),
IECore.V2i(320, 0),
IECore.V2i(639, 0),
IECore.V2i(639, 240),
IECore.V2i(639, 479),
IECore.V2i(320, 479),
IECore.V2i(0, 479),
IECore.V2i(0, 240),
]
for point in edges:
index = dimensions.x * point.y + point.x
self.failUnless(image["R"][index] < 0.1)
self.failUnless(image["G"][index] > 0.8)
innerEdges = [
IECore.V2i(3, 3),
IECore.V2i(320, 3),
IECore.V2i(637, 3),
IECore.V2i(636, 240),
IECore.V2i(636, 477),
IECore.V2i(320, 477),
IECore.V2i(3, 477),
IECore.V2i(3, 240),
]
for point in innerEdges:
index = dimensions.x * point.y + point.x
self.failUnless(image["R"][index] > 0.8)
self.failUnless(image["G"][index] < 0.1)
def testTypeName(self):
r = IECoreArnold.Renderer()
self.assertEqual(r.typeName(), "IECoreArnold::Renderer")
def testShaderSubstitutions( self ) : s = Gaffer.ScriptNode() s["plane"] = GafferScene.Plane() s["planeAttrs"] = GafferScene.CustomAttributes() s["planeAttrs"]["in"].setInput( s["plane"]["out"] ) s["planeAttrs"]["attributes"].addChild( Gaffer.NameValuePlug( "A", Gaffer.StringPlug( "value", defaultValue = 'bar' ) ) ) s["planeAttrs"]["attributes"].addChild( Gaffer.NameValuePlug( "B", Gaffer.StringPlug( "value", defaultValue = 'foo' ) ) ) s["cube"] = GafferScene.Cube() s["cubeAttrs"] = GafferScene.CustomAttributes() s["cubeAttrs"]["in"].setInput( s["cube"]["out"] ) s["cubeAttrs"]["attributes"].addChild( Gaffer.NameValuePlug( "B", Gaffer.StringPlug( "value", defaultValue = 'override' ) ) ) s["parent"] = GafferScene.Parent() s["parent"]["in"].setInput( s["planeAttrs"]["out"] ) s["parent"]["children"][0].setInput( s["cubeAttrs"]["out"] ) s["parent"]["parent"].setValue( "/plane" ) s["shader"] = GafferArnold.ArnoldShader() s["shader"].loadShader( "image" ) s["shader"]["parameters"]["filename"].setValue( "<attr:A>/path/<attr:B>.tx" ) s["filter"] = GafferScene.PathFilter() s["filter"]["paths"].setValue( IECore.StringVectorData( [ "/plane" ] ) ) s["shaderAssignment"] = GafferScene.ShaderAssignment() s["shaderAssignment"]["in"].setInput( s["parent"]["out"] ) s["shaderAssignment"]["filter"].setInput( s["filter"]["out"] ) s["shaderAssignment"]["shader"].setInput( s["shader"]["out"] ) s["light"] = GafferArnold.ArnoldLight() s["light"].loadShader( "photometric_light" ) s["light"]["parameters"]["filename"].setValue( "/path/<attr:A>.ies" ) s["goboTexture"] = GafferArnold.ArnoldShader() s["goboTexture"].loadShader( "image" ) s["goboTexture"]["parameters"]["filename"].setValue( "<attr:B>/gobo.tx" ) s["gobo"] = GafferArnold.ArnoldShader() s["gobo"].loadShader( "gobo" ) s["gobo"]["parameters"]["slidemap"].setInput( s["goboTexture"]["out"] ) s["goboAssign"] = GafferScene.ShaderAssignment() s["goboAssign"]["in"].setInput( s["light"]["out"] ) s["goboAssign"]["shader"].setInput( s["gobo"]["out"] ) s["lightBlocker"] = GafferArnold.ArnoldLightFilter() s["lightBlocker"].loadShader( "light_blocker" ) s["lightBlocker"]["parameters"]["geometry_type"].setValue( "<attr:geometryType>" ) s["lightGroup"] = GafferScene.Group() s["lightGroup"]["name"].setValue( "lightGroup" ) s["lightGroup"]["in"][0].setInput( s["goboAssign"]["out"] ) s["lightGroup"]["in"][1].setInput( s["lightBlocker"]["out"] ) s["parent2"] = GafferScene.Parent() s["parent2"]["in"].setInput( s["shaderAssignment"]["out"] ) s["parent2"]["children"][0].setInput( s["lightGroup"]["out"] ) s["parent2"]["parent"].setValue( "/" ) s["globalAttrs"] = GafferScene.CustomAttributes() s["globalAttrs"]["in"].setInput( s["parent2"]["out"] ) s["globalAttrs"]["global"].setValue( True ) s["globalAttrs"]["attributes"].addChild( Gaffer.NameValuePlug( "A", Gaffer.StringPlug( "value", defaultValue = 'default1' ) ) ) s["globalAttrs"]["attributes"].addChild( Gaffer.NameValuePlug( "B", Gaffer.StringPlug( "value", defaultValue = 'default2' ) ) ) s["globalAttrs"]["attributes"].addChild( Gaffer.NameValuePlug( "geometryType", Gaffer.StringPlug( "value", defaultValue = 'cylinder' ) ) ) s["render"] = GafferArnold.ArnoldRender() s["render"]["in"].setInput( s["globalAttrs"]["out"] ) s["render"]["mode"].setValue( s["render"].Mode.SceneDescriptionMode ) s["render"]["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) plane = arnold.AiNodeLookUpByName( "/plane" ) shader = arnold.AiNodeGetPtr( plane, "shader" ) self.assertEqual( arnold.AiNodeGetStr( shader, "filename" ), "bar/path/foo.tx" ) cube = arnold.AiNodeLookUpByName( "/plane/cube" ) shader2 = arnold.AiNodeGetPtr( cube, "shader" ) self.assertEqual( arnold.AiNodeGetStr( shader2, "filename" ), "bar/path/override.tx" ) light = arnold.AiNodeLookUpByName( "light:/lightGroup/light" ) self.assertEqual( arnold.AiNodeGetStr( light, "filename" ), "/path/default1.ies" ) gobo = arnold.AiNodeGetPtr( light, "filters" ) goboTex = arnold.AiNodeGetLink( gobo, "slidemap" ) self.assertEqual( arnold.AiNodeGetStr( goboTex, "filename" ), "default2/gobo.tx" ) lightFilter = arnold.AiNodeLookUpByName( "lightFilter:/lightGroup/lightFilter" ) self.assertEqual( arnold.AiNodeGetStr( lightFilter, "geometry_type" ), "cylinder" )
def testVertexToVaryingConversion(self):
c = IECoreScene.CurvesPrimitive(IECore.IntVectorData([2, 2]),
IECore.CubicBasisf.linear())
c["P"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([imath.V3f(x, 0, 0) for x in range(0, 4)]))
c["width"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([1] * 4),
)
c["foo"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([1.5] * 4))
self.assertTrue(c.arePrimitiveVariablesValid())
c2 = c.copy()
c2["width"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([2] * 4),
)
self.assertTrue(c2.arePrimitiveVariablesValid())
c3 = IECoreScene.CurvesPrimitive(IECore.IntVectorData([8, 8]),
IECore.CubicBasisf.bSpline())
c3["P"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData([
imath.V3f(0, 0, 0),
imath.V3f(0, 0, 0),
imath.V3f(0, 0, 0),
imath.V3f(0, 0.75, 0),
imath.V3f(0.25, 1, 0),
imath.V3f(1, 1, 0),
imath.V3f(1, 1, 0),
imath.V3f(1, 1, 0),
imath.V3f(0, 0, 1),
imath.V3f(0, 0, 1),
imath.V3f(0, 0, 1),
imath.V3f(0, 0.75, 1),
imath.V3f(0.25, 1, 1),
imath.V3f(1, 1, 1),
imath.V3f(1, 1, 1),
imath.V3f(1, 1, 1)
]),
)
c3["width"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([1] * 16),
)
c3["foo"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([1.5] * 16))
self.assertTrue(c3.arePrimitiveVariablesValid())
c4 = c3.copy()
c4["width"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData([2] * 16),
)
self.assertTrue(c4.arePrimitiveVariablesValid())
with IECoreArnold.UniverseBlock(writable=True) as universe:
n = IECoreArnold.NodeAlgo.convert(c, universe, "testLinearCurve")
r = arnold.AiNodeGetArray(n, "radius")
self.assertEqual(arnold.AiArrayGetNumElements(r.contents), 4)
self.assertEqual(arnold.AiArrayGetNumKeys(r.contents), 1)
foo = arnold.AiNodeGetArray(n, "foo")
self.assertEqual(arnold.AiArrayGetNumElements(foo.contents), 4)
self.assertEqual(arnold.AiArrayGetNumKeys(foo.contents), 1)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetFlt(r, i), 0.5)
self.assertEqual(arnold.AiArrayGetFlt(foo, i), 1.5)
n2 = IECoreArnold.NodeAlgo.convert([c, c2], -0.25, 0.25, universe,
"testLinearCurves")
r2 = arnold.AiNodeGetArray(n2, "radius")
self.assertEqual(arnold.AiArrayGetNumElements(r2.contents), 4)
self.assertEqual(arnold.AiArrayGetNumKeys(r2.contents), 2)
foo2 = arnold.AiNodeGetArray(n2, "foo")
self.assertEqual(arnold.AiArrayGetNumElements(foo2.contents), 4)
# arbitrary userdata is not sampled
self.assertEqual(arnold.AiArrayGetNumKeys(foo2.contents), 1)
for i in range(0, 4):
self.assertEqual(arnold.AiArrayGetFlt(r2, i), 0.5)
self.assertEqual(arnold.AiArrayGetFlt(foo2, i), 1.5)
for i in range(4, 8):
self.assertEqual(arnold.AiArrayGetFlt(r2, i), 1)
# for cubic curves, radius will have been converted to Varying, so it will have fewer elements
n3 = IECoreArnold.NodeAlgo.convert(c3, universe,
"testBSplineCurve")
r3 = arnold.AiNodeGetArray(n3, "radius")
self.assertEqual(arnold.AiArrayGetNumElements(r3.contents), 12)
self.assertEqual(arnold.AiArrayGetNumKeys(r3.contents), 1)
foo3 = arnold.AiNodeGetArray(n3, "foo")
self.assertEqual(arnold.AiArrayGetNumElements(foo3.contents), 12)
self.assertEqual(arnold.AiArrayGetNumKeys(foo3.contents), 1)
for i in range(0, 12):
self.assertEqual(arnold.AiArrayGetFlt(r3, i), 0.5)
self.assertEqual(arnold.AiArrayGetFlt(foo3, i), 1.5)
n4 = IECoreArnold.NodeAlgo.convert([c3, c4], -0.25, 0.25, universe,
"testBSplineCurves")
r4 = arnold.AiNodeGetArray(n4, "radius")
self.assertEqual(arnold.AiArrayGetNumElements(r4.contents), 12)
self.assertEqual(arnold.AiArrayGetNumKeys(r4.contents), 2)
foo4 = arnold.AiNodeGetArray(n4, "foo")
self.assertEqual(arnold.AiArrayGetNumElements(foo4.contents), 12)
# arbitrary userdata is not sampled
self.assertEqual(arnold.AiArrayGetNumKeys(foo4.contents), 1)
for i in range(0, 12):
self.assertEqual(arnold.AiArrayGetFlt(r4, i), 0.5)
self.assertEqual(arnold.AiArrayGetFlt(foo4, i), 1.5)
for i in range(12, 24):
self.assertEqual(arnold.AiArrayGetFlt(r4, i), 1)
def testLightAndShadowLinking( self ) : sphere1 = GafferScene.Sphere() sphere2 = GafferScene.Sphere() attributes = GafferScene.StandardAttributes() arnoldAttributes = GafferArnold.ArnoldAttributes() light1 = GafferArnold.ArnoldLight() light1.loadShader( "point_light" ) light2 = GafferArnold.ArnoldLight() light2.loadShader( "point_light" ) group = GafferScene.Group() render = GafferArnold.ArnoldRender() attributes["in"].setInput( sphere1["out"] ) arnoldAttributes["in"].setInput( attributes["out"] ) group["in"][0].setInput( arnoldAttributes["out"] ) group["in"][1].setInput( light1["out"] ) group["in"][2].setInput( light2["out"] ) group["in"][3].setInput( sphere2["out"] ) render["in"].setInput( group["out"] ) # Illumination attributes["attributes"]["linkedLights"]["enabled"].setValue( True ) attributes["attributes"]["linkedLights"]["value"].setValue( "/group/light" ) # Shadows arnoldAttributes["attributes"]["shadowGroup"]["enabled"].setValue( True ) arnoldAttributes["attributes"]["shadowGroup"]["value"].setValue( "/group/light1" ) render["mode"].setValue( render.Mode.SceneDescriptionMode ) render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" ) render["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) # the first sphere had linked lights sphere = arnold.AiNodeLookUpByName( "/group/sphere" ) # check illumination self.assertTrue( arnold.AiNodeGetBool( sphere, "use_light_group" ) ) lights = arnold.AiNodeGetArray( sphere, "light_group" ) self.assertEqual( arnold.AiArrayGetNumElements( lights ), 1 ) self.assertEqual( arnold.AiNodeGetName( arnold.AiArrayGetPtr( lights, 0 ) ), "light:/group/light" ) # check shadows self.assertTrue( arnold.AiNodeGetBool( sphere, "use_shadow_group" ) ) shadows = arnold.AiNodeGetArray( sphere, "shadow_group" ) self.assertEqual( arnold.AiArrayGetNumElements( shadows ), 1 ) self.assertEqual( arnold.AiNodeGetName( arnold.AiArrayGetPtr( shadows, 0 ) ), "light:/group/light1" ) # the second sphere does not have any light linking enabled sphere1 = arnold.AiNodeLookUpByName( "/group/sphere1" ) # check illumination self.assertFalse( arnold.AiNodeGetBool( sphere1, "use_light_group" ) ) lights = arnold.AiNodeGetArray( sphere1, "light_group" ) self.assertEqual( arnold.AiArrayGetNumElements( lights ), 0 ) # check shadows self.assertFalse( arnold.AiNodeGetBool( sphere1, "use_shadow_group" ) ) shadows = arnold.AiNodeGetArray( sphere1, "shadow_group" ) self.assertEqual( arnold.AiArrayGetNumElements( shadows ), 0 )
def testTransformMotion( self ) : s = Gaffer.ScriptNode() s["plane"] = GafferScene.Plane() s["sphere"] = GafferScene.Sphere() s["group"] = GafferScene.Group() s["group"]["in"][0].setInput( s["plane"]["out"] ) s["group"]["in"][1].setInput( s["sphere"]["out"] ) s["expression"] = Gaffer.Expression() s["expression"].setExpression( inspect.cleandoc( """ parent["plane"]["transform"]["translate"]["x"] = context.getFrame() parent["sphere"]["transform"]["translate"]["y"] = context.getFrame() * 2 parent["group"]["transform"]["translate"]["z"] = context.getFrame() - 1 """ ) ) s["planeFilter"] = GafferScene.PathFilter() s["planeFilter"]["paths"].setValue( IECore.StringVectorData( [ "/group/plane" ] ) ) s["attributes"] = GafferScene.StandardAttributes() s["attributes"]["in"].setInput( s["group"]["out"] ) s["attributes"]["filter"].setInput( s["planeFilter"]["out"] ) s["attributes"]["attributes"]["transformBlur"]["enabled"].setValue( True ) s["attributes"]["attributes"]["transformBlur"]["value"].setValue( False ) s["options"] = GafferScene.StandardOptions() s["options"]["in"].setInput( s["attributes"]["out"] ) s["options"]["options"]["shutter"]["enabled"].setValue( True ) s["options"]["options"]["transformBlur"]["enabled"].setValue( True ) 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" ) # No motion blur s["options"]["options"]["transformBlur"]["value"].setValue( False ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) camera = arnold.AiNodeLookUpByName( "gaffer:defaultCamera" ) sphere = arnold.AiNodeLookUpByName( "/group/sphere" ) sphereMotionStart = arnold.AiNodeGetFlt( sphere, "motion_start" ) sphereMotionEnd = arnold.AiNodeGetFlt( sphere, "motion_end" ) sphereMatrix = arnold.AiNodeGetMatrix( sphere, "matrix" ) plane = arnold.AiNodeLookUpByName( "/group/plane" ) planeMotionStart = arnold.AiNodeGetFlt( plane, "motion_start" ) planeMotionEnd = arnold.AiNodeGetFlt( plane, "motion_end" ) planeMatrix = arnold.AiNodeGetMatrix( plane, "matrix" ) # Motion parameters should be left at default self.assertEqual( sphereMotionStart, 0 ) self.assertEqual( sphereMotionEnd, 1 ) self.assertEqual( planeMotionStart, 0 ) self.assertEqual( planeMotionEnd, 1 ) expectedSphereMatrix = arnold.AiM4Translation( arnold.AtVector( 0, 2, 0 ) ) expectedPlaneMatrix = arnold.AiM4Translation( arnold.AtVector( 1, 0, 0 ) ) self.assertEqual( self.__m44f( sphereMatrix ), self.__m44f( expectedSphereMatrix ) ) self.assertEqual( self.__m44f( planeMatrix ), self.__m44f( expectedPlaneMatrix ) ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_start" ), 1 ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_end" ), 1 ) # Motion blur s["options"]["options"]["transformBlur"]["value"].setValue( True ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) camera = arnold.AiNodeLookUpByName( "gaffer:defaultCamera" ) sphere = arnold.AiNodeLookUpByName( "/group/sphere" ) sphereMotionStart = arnold.AiNodeGetFlt( sphere, "motion_start" ) sphereMotionEnd = arnold.AiNodeGetFlt( sphere, "motion_end" ) sphereMatrices = arnold.AiNodeGetArray( sphere, "matrix" ) plane = arnold.AiNodeLookUpByName( "/group/plane" ) planeMotionStart = arnold.AiNodeGetFlt( plane, "motion_start" ) planeMotionEnd = arnold.AiNodeGetFlt( plane, "motion_end" ) planeMatrices = arnold.AiNodeGetArray( plane, "matrix" ) self.assertEqual( sphereMotionStart, 0.75 ) self.assertEqual( sphereMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( sphereMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( sphereMatrices.contents ), 2 ) self.assertEqual( planeMotionStart, 0.75 ) self.assertEqual( planeMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( planeMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( planeMatrices.contents ), 2 ) for i in range( 0, 2 ) : frame = 0.75 + 0.5 * i sphereMatrix = arnold.AiArrayGetMtx( sphereMatrices, i ) expectedSphereMatrix = arnold.AiM4Translation( arnold.AtVector( 0, frame * 2, frame - 1 ) ) planeMatrix = arnold.AiArrayGetMtx( planeMatrices, i ) expectedPlaneMatrix = arnold.AiM4Translation( arnold.AtVector( 1, 0, frame - 1 ) ) self.assertEqual( self.__m44f( sphereMatrix ), self.__m44f( expectedSphereMatrix ) ) self.assertEqual( self.__m44f( planeMatrix ), self.__m44f( expectedPlaneMatrix ) ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_start" ), 0.75 ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_end" ), 1.25 ) # Motion blur on, but sampleMotion off s["options"]["options"]["sampleMotion"]["enabled"].setValue( True ) s["options"]["options"]["sampleMotion"]["value"].setValue( False ) s["render"]["task"].execute() with IECoreArnold.UniverseBlock( writable = True ) : arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" ) camera = arnold.AiNodeLookUpByName( "gaffer:defaultCamera" ) sphere = arnold.AiNodeLookUpByName( "/group/sphere" ) sphereMotionStart = arnold.AiNodeGetFlt( sphere, "motion_start" ) sphereMotionEnd = arnold.AiNodeGetFlt( sphere, "motion_end" ) sphereMatrices = arnold.AiNodeGetArray( sphere, "matrix" ) plane = arnold.AiNodeLookUpByName( "/group/plane" ) planeMotionStart = arnold.AiNodeGetFlt( plane, "motion_start" ) planeMotionEnd = arnold.AiNodeGetFlt( plane, "motion_end" ) planeMatrices = arnold.AiNodeGetArray( plane, "matrix" ) self.assertEqual( sphereMotionStart, 0.75 ) self.assertEqual( sphereMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( sphereMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( sphereMatrices.contents ), 2 ) self.assertEqual( planeMotionStart, 0.75 ) self.assertEqual( planeMotionEnd, 1.25 ) self.assertEqual( arnold.AiArrayGetNumElements( planeMatrices.contents ), 1 ) self.assertEqual( arnold.AiArrayGetNumKeys( planeMatrices.contents ), 2 ) for i in range( 0, 2 ) : frame = 0.75 + 0.5 * i sphereMatrix = arnold.AiArrayGetMtx( sphereMatrices, i ) expectedSphereMatrix = arnold.AiM4Translation( arnold.AtVector( 0, frame * 2, frame - 1 ) ) planeMatrix = arnold.AiArrayGetMtx( planeMatrices, i ) expectedPlaneMatrix = arnold.AiM4Translation( arnold.AtVector( 1, 0, frame - 1 ) ) self.assertEqual( self.__m44f( sphereMatrix ), self.__m44f( expectedSphereMatrix ) ) self.assertEqual( self.__m44f( planeMatrix ), self.__m44f( expectedPlaneMatrix ) ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_start" ), 0.75 ) self.assertEqual( arnold.AiNodeGetFlt( camera, "shutter_end" ), 0.75 )
def testUpdate(self):
network = IECoreScene.ShaderNetwork(shaders={
"noiseHandle":
IECoreScene.Shader("noise"),
"flatHandle":
IECoreScene.Shader("flat"),
},
connections=[
(("noiseHandle", ""),
("flatHandle", "color")),
],
output="flatHandle")
with IECoreArnold.UniverseBlock(writable=True):
# Convert
nodes = IECoreArnoldPreview.ShaderNetworkAlgo.convert(
network, "test")
def assertNoiseAndFlatNodes():
self.assertEqual(len(nodes), 2)
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(nodes[0])), "noise")
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(nodes[1])), "flat")
self.assertEqual(arnold.AiNodeGetName(nodes[0]),
"test:noiseHandle")
self.assertEqual(arnold.AiNodeGetName(nodes[1]), "test")
self.assertEqual(
ctypes.addressof(
arnold.AiNodeGetLink(nodes[1], "color").contents),
ctypes.addressof(nodes[0].contents))
assertNoiseAndFlatNodes()
# Convert again with no changes at all. We want to see the same nodes reused.
originalNodes = nodes[:]
self.assertTrue(
IECoreArnoldPreview.ShaderNetworkAlgo.update(nodes, network))
assertNoiseAndFlatNodes()
self.assertEqual(ctypes.addressof(nodes[0].contents),
ctypes.addressof(originalNodes[0].contents))
self.assertEqual(ctypes.addressof(nodes[1].contents),
ctypes.addressof(originalNodes[1].contents))
# Convert again with a tweak to a noise parameter. We want to see the same nodes
# reused, with the new parameter value taking hold.
noise = network.getShader("noiseHandle")
noise.parameters["octaves"] = IECore.IntData(3)
network.setShader("noiseHandle", noise)
originalNodes = nodes[:]
self.assertTrue(
IECoreArnoldPreview.ShaderNetworkAlgo.update(nodes, network))
assertNoiseAndFlatNodes()
self.assertEqual(ctypes.addressof(nodes[0].contents),
ctypes.addressof(originalNodes[0].contents))
self.assertEqual(ctypes.addressof(nodes[1].contents),
ctypes.addressof(originalNodes[1].contents))
self.assertEqual(arnold.AiNodeGetInt(nodes[0], "octaves"), 3)
# Remove the noise shader, and replace it with an image. Make sure the new network is as we expect, and
# the old noise node has been destroyed.
network.removeShader("noiseHandle")
network.setShader("imageHandle", IECoreScene.Shader("image"))
network.addConnection(
(("imageHandle", ""), ("flatHandle", "color")))
originalNodes = nodes[:]
self.assertTrue(
IECoreArnoldPreview.ShaderNetworkAlgo.update(nodes, network))
self.assertEqual(ctypes.addressof(nodes[1].contents),
ctypes.addressof(originalNodes[1].contents))
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(nodes[0])),
"image")
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(nodes[1])),
"flat")
self.assertEqual(arnold.AiNodeGetName(nodes[0]),
"test:imageHandle")
self.assertEqual(arnold.AiNodeGetName(nodes[1]), "test")
self.assertEqual(
ctypes.addressof(
arnold.AiNodeGetLink(nodes[1], "color").contents),
ctypes.addressof(nodes[0].contents))
self.assertIsNone(arnold.AiNodeLookUpByName("test:noiseHandle"))
# Replace the output shader with something else.
network.removeShader("flatHandle")
network.setShader("lambertHandle", IECoreScene.Shader("lambert"))
network.addConnection(
(("imageHandle", ""), ("lambertHandle", "Kd_color")))
network.setOutput(("lambertHandle", ""))
originalNodes = nodes[:]
self.assertFalse(
IECoreArnoldPreview.ShaderNetworkAlgo.update(nodes, network))
self.assertEqual(ctypes.addressof(nodes[0].contents),
ctypes.addressof(originalNodes[0].contents))
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(nodes[0])),
"image")
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(nodes[1])),
"lambert")
self.assertEqual(arnold.AiNodeGetName(nodes[0]),
"test:imageHandle")
self.assertEqual(arnold.AiNodeGetName(nodes[1]), "test")
self.assertEqual(
ctypes.addressof(
arnold.AiNodeGetLink(nodes[1], "Kd_color").contents),
ctypes.addressof(nodes[0].contents))
def testLightAndShadowLinking( self ) :
sphere1 = GafferScene.Sphere()
sphere2 = GafferScene.Sphere()
attributes = GafferScene.StandardAttributes()
arnoldAttributes = GafferArnold.ArnoldAttributes()
light1 = GafferArnold.ArnoldLight()
light1.loadShader( "point_light" )
light2 = GafferArnold.ArnoldLight()
light2.loadShader( "point_light" )
group = GafferScene.Group()
group["in"].addChild( GafferScene.ScenePlug( "in1" ) )
group["in"].addChild( GafferScene.ScenePlug( "in2" ) )
group["in"].addChild( GafferScene.ScenePlug( "in3" ) )
group["in"].addChild( GafferScene.ScenePlug( "in4" ) )
evaluate = GafferScene.EvaluateLightLinks()
render = GafferArnold.ArnoldRender()
attributes["in"].setInput( sphere1["out"] )
arnoldAttributes["in"].setInput( attributes["out"] )
group["in"]["in1"].setInput( arnoldAttributes["out"] )
group["in"]["in2"].setInput( light1["out"] )
group["in"]["in3"].setInput( light2["out"] )
group["in"]["in4"].setInput( sphere2["out"] )
evaluate["in"].setInput( group["out"] )
render["in"].setInput( evaluate["out"] )
# Illumination
attributes["attributes"]["linkedLights"]["enabled"].setValue( True )
attributes["attributes"]["linkedLights"]["value"].setValue( "/group/light /group/light1" )
# Shadows
arnoldAttributes["attributes"]["shadowGroup"]["enabled"].setValue( True )
arnoldAttributes["attributes"]["shadowGroup"]["value"].setValue( "/group/light /group/light1" )
# make sure we pass correct data into the renderer
self.assertEqual(
set( render["in"].attributes( "/group/sphere" )["linkedLights"] ),
set( IECore.StringVectorData( ["/group/light", "/group/light1"] ) )
)
self.assertEqual(
set( render["in"].attributes( "/group/sphere" )["ai:visibility:shadow_group"] ),
set( IECore.StringVectorData( ["/group/light", "/group/light1"] ) )
)
render["mode"].setValue( render.Mode.SceneDescriptionMode )
render["fileName"].setValue( self.temporaryDirectory() + "/test.ass" )
render["task"].execute()
with IECoreArnold.UniverseBlock( writable = True ) :
arnold.AiASSLoad( self.temporaryDirectory() + "/test.ass" )
# the first sphere had linked lights
sphere = arnold.AiNodeLookUpByName( "/group/sphere" )
# check illumination
lights = arnold.AiNodeGetArray( sphere, "light_group" )
lightNames = []
for i in range( arnold.AiArrayGetNumElements( lights.contents ) ):
light = arnold.cast(arnold.AiArrayGetPtr(lights, i), arnold.POINTER(arnold.AtNode))
lightNames.append( arnold.AiNodeGetName(light.contents) )
doLinking = arnold.AiNodeGetBool( sphere, "use_light_group" )
self.assertEqual( set( lightNames ), { "light:/group/light", "light:/group/light1" } )
self.assertEqual( doLinking, True )
# check shadows
shadows = arnold.AiNodeGetArray( sphere, "shadow_group" )
lightNames = []
for i in range( arnold.AiArrayGetNumElements( shadows.contents ) ):
light = arnold.cast(arnold.AiArrayGetPtr(shadows, i), arnold.POINTER(arnold.AtNode))
lightNames.append( arnold.AiNodeGetName(light.contents) )
doLinking = arnold.AiNodeGetBool( sphere, "use_shadow_group" )
self.assertEqual( set( lightNames ), { "light:/group/light", "light:/group/light1" } )
self.assertEqual( doLinking, True )
# the second sphere does not have any light linking enabled
sphere1 = arnold.AiNodeLookUpByName( "/group/sphere1" )
# check illumination
lights = arnold.AiNodeGetArray( sphere1, "light_group" )
lightNames = []
for i in range( arnold.AiArrayGetNumElements( lights.contents ) ):
light = arnold.cast(arnold.AiArrayGetPtr(lights, i), arnold.POINTER(arnold.AtNode))
lightNames.append( arnold.AiNodeGetName(light.contents) )
doLinking = arnold.AiNodeGetBool( sphere1, "use_light_group" )
self.assertEqual( lightNames, [] )
self.assertEqual( doLinking, False )
# check shadows
shadows = arnold.AiNodeGetArray( sphere1, "shadow_group" )
lightNames = []
for i in range( arnold.AiArrayGetNumElements( shadows.contents ) ):
light = arnold.cast(arnold.AiArrayGetPtr(shadows, i), arnold.POINTER(arnold.AtNode))
lightNames.append( arnold.AiNodeGetName(light.contents) )
doLinking = arnold.AiNodeGetBool( sphere1, "use_shadow_group" )
self.assertEqual( lightNames, [] )
self.assertEqual( doLinking, False )
# collapsible section.
sectionNameWithHeading = sectionName + ("." if sectionName else
"") + parameter.contents
__metadata[nodeName + ".parameters"]["layout:section:" +
sectionNameWithHeading +
":collapsed"] = False
elif parameter.type == "arnold":
__metadata[
nodeName + ".parameters." +
parameter.name]["layout:section"] = sectionNameWithHeading
with IECoreArnold.UniverseBlock():
nodeIt = arnold.AiUniverseGetNodeEntryIterator(arnold.AI_NODE_SHADER
| arnold.AI_NODE_LIGHT)
while not arnold.AiNodeEntryIteratorFinished(nodeIt):
__translateNodeMetadata(arnold.AiNodeEntryIteratorGetNext(nodeIt))
##########################################################################
# Gaffer Metadata queries. These are implemented using the preconstructed
# registry above.
##########################################################################
def __nodeDescription(node):
