def testUserSuppliedHash( self ) : with IECoreArnold.UniverseBlock( writable = True ) : c = IECoreArnold.InstancingConverter() m1 = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ) ) m2 = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( -2 ), imath.V2f( 2 ) ) ) h1 = IECore.MurmurHash() h2 = IECore.MurmurHash() h1.append( 10 ) h2.append( 10 ) am1a = c.convert( m1, h1, "testMesh" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( am1a ) ), "polymesh" ) am1b = c.convert( m1, h1, "testInstance" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( am1b ) ), "ginstance" ) self.assertEqual( arnold.AiNodeGetPtr( am1b, "node" ), ctypes.addressof( am1a.contents ) ) am2a = c.convert( m2, h2, "testMesh" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( am2a ) ), "polymesh" ) am2b = c.convert( m2, h2, "testInstance" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( am2b ) ), "ginstance" ) self.assertEqual( arnold.AiNodeGetPtr( am2b, "node" ), ctypes.addressof( am2a.contents ) )
def test(self):
with IECoreArnold.UniverseBlock(writable=True):
c = IECoreArnold.InstancingConverter()
m1 = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
m2 = m1.copy()
m3 = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-2), IECore.V2f(2)))
am1 = c.convert(m1)
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(am1)),
"polymesh")
am2 = c.convert(m2)
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(am2)),
"ginstance")
self.assertEqual(arnold.AiNodeGetPtr(am2, "node"),
ctypes.addressof(am1.contents))
am3 = c.convert(m3)
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(am3)),
"polymesh")
def test(self):
network = IECoreScene.ShaderNetwork(shaders={
"noiseHandle":
IECoreScene.Shader("noise"),
"flatHandle":
IECoreScene.Shader("flat"),
},
connections=[
(("noiseHandle", ""),
("flatHandle", "color")),
],
output="flatHandle")
with IECoreArnold.UniverseBlock(writable=True):
nodes = IECoreArnoldPreview.ShaderNetworkAlgo.convert(
network, "test")
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))
def testLightFilters(self):
s = Gaffer.ScriptNode()
s["lightFilter"] = GafferArnold.ArnoldLightFilter()
s["lightFilter"].loadShader("light_blocker")
s["attributes"] = GafferScene.StandardAttributes()
s["attributes"]["in"].setInput(s["lightFilter"]["out"])
s["attributes"]["attributes"]["filteredLights"]["enabled"].setValue(
True)
s["attributes"]["attributes"]["filteredLights"]["value"].setValue(
"defaultLights")
s["light"] = GafferArnold.ArnoldLight()
s["light"].loadShader("point_light")
s["gobo"] = GafferArnold.ArnoldShader()
s["gobo"].loadShader("gobo")
s["assignment"] = GafferScene.ShaderAssignment()
s["assignment"]["in"].setInput(s["light"]["out"])
s["assignment"]["shader"].setInput(s["gobo"]["out"])
s["group"] = GafferScene.Group()
s["group"]["in"][0].setInput(s["attributes"]["out"])
s["group"]["in"][1].setInput(s["assignment"]["out"])
s["render"] = GafferArnold.ArnoldRender()
s["render"]["in"].setInput(s["group"]["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")
light = arnold.AiNodeLookUpByName("light:/group/light")
linkedFilters = arnold.AiNodeGetArray(light, "filters")
numFilters = arnold.AiArrayGetNumElements(linkedFilters.contents)
self.assertEqual(numFilters, 2)
linkedFilter = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 0),
arnold.POINTER(arnold.AtNode))
linkedGobo = arnold.cast(arnold.AiArrayGetPtr(linkedFilters, 1),
arnold.POINTER(arnold.AtNode))
self.assertEqual(arnold.AiNodeGetName(linkedFilter),
"lightFilter:/group/lightFilter")
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(linkedFilter)), "light_blocker")
self.assertEqual(
arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(linkedGobo)), "gobo")
def testBlindData(self):
flat = IECoreScene.Shader("flat")
flat.blindData().update({
"user:testInt":
IECore.IntData(1),
"user:testFloat":
IECore.FloatData(2.5),
"user:testV3f":
IECore.V3fData(imath.V3f(1, 2, 3)),
"user:testColor3f":
IECore.Color3fData(imath.Color3f(4, 5, 6)),
"user:testString":
IECore.StringData("we're all doomed"),
})
network = IECoreScene.ShaderNetwork(shaders={
"noiseHandle":
IECoreScene.Shader("noise"),
"flatHandle":
flat,
},
connections=[
(("noiseHandle", ""),
("flatHandle", "color")),
],
output="flatHandle")
with IECoreArnold.UniverseBlock(writable=True) as universe:
nodes = IECoreArnoldPreview.ShaderNetworkAlgo.convert(
network, universe, "test")
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(arnold.AiNodeGetInt(nodes[1], "user:testInt"), 1)
self.assertEqual(arnold.AiNodeGetFlt(nodes[1], "user:testFloat"),
2.5)
self.assertEqual(arnold.AiNodeGetVec(nodes[1], "user:testV3f"),
arnold.AtVector(1, 2, 3))
self.assertEqual(arnold.AiNodeGetRGB(nodes[1], "user:testColor3f"),
arnold.AtRGB(4, 5, 6))
self.assertEqual(arnold.AiNodeGetStr(nodes[1], "user:testString"),
"we're all doomed")
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 ) )
def testEnabling(self):
r = IECoreArnold.Renderer()
with IECore.WorldBlock(r):
r.setAttribute("ai:automaticInstancing", IECore.BoolData(True))
m = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
m.render(r)
m.render(r)
nodes = self.__allNodes(type=arnold.AI_NODE_SHAPE)
self.assertEqual(len(nodes), 2)
nodeTypes = [
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n))
for n in nodes
]
mesh = nodes[nodeTypes.index("polymesh")]
instance = nodes[nodeTypes.index("ginstance")]
self.assertEqual(arnold.AiNodeGetPtr(instance, "node"),
ctypes.addressof(mesh.contents))
def testConvertPerspective(self):
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(
IECoreScene.Camera(
parameters={
"projection":
"perspective",
"projection:fov":
45.0,
"resolution":
imath.V2i(512),
"screenWindow":
imath.Box2f(imath.V2f(-1, -0.5), imath.V2f(1, 0.5))
}), "testCamera")
self.assertTrue(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n)),
"persp_camera")
self.assertEqual(arnold.AiNodeGetFlt(n, "fov"), 45.0)
self.assertEqual(arnold.AiNodeGetVec2(n, "screen_window_min"),
arnold.AtVector2(-1, -0.5))
self.assertEqual(arnold.AiNodeGetVec2(n, "screen_window_max"),
arnold.AtVector2(1, 0.5))
def testProcedural(self):
r = IECoreArnold.Renderer("/tmp/test.ass")
with IECore.WorldBlock(r):
r.procedural(
r.ExternalProcedural(
"someVolumeThing.so",
IECore.Box3f(IECore.V3f(-1, -2, -3), IECore.V3f(4, 5, 6)),
{
"ai:nodeType": "volume",
"testFloat": 0.5
}))
volume = self.__allNodes(type=arnold.AI_NODE_SHAPE)[-1]
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(volume)),
"volume")
self.assertEqual(arnold.AiNodeGetPnt(volume, "min"),
arnold.AtPoint(-1, -2, -3))
self.assertEqual(arnold.AiNodeGetPnt(volume, "max"),
arnold.AtPoint(4, 5, 6))
self.assertEqual(arnold.AiNodeGetStr(volume, "dso"),
"someVolumeThing.so")
self.assertEqual(arnold.AiNodeGetFlt(volume, "testFloat"), 0.5)
def testConvertPerspective( self ) :
with IECoreArnold.UniverseBlock( writable = True ) :
c = IECoreScene.Camera(
parameters = {
"projection" : "perspective",
"focalLength" : 1 / ( 2.0 * math.tan( 0.5 * math.radians( 45 ) ) ),
"resolution" : imath.V2i( 512 ),
"aperture" : imath.V2f( 2, 1 )
}
)
n = IECoreArnold.NodeAlgo.convert( c, "testCamera" )
screenWindow = c.frustum()
self.assertTrue( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "persp_camera" )
screenWindowMult = math.tan( 0.5 * math.radians( arnold.AiNodeGetFlt( n, "fov" ) ) )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).x, screenWindow.min()[0], 6 )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).y, screenWindow.min()[1], 6 )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).x, screenWindow.max()[0], 6 )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).y, screenWindow.max()[1], 6 )
# For perspective cameras, we set a FOV value that drives the effective screen window.
# As long as pixels aren't distorted, and there is no aperture offset,
# applying Arnold's automatic screen window computation to a default screen window
# should give us the correct result
self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_min" ).x, -1.0 )
self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_min" ).y, -1.0 )
self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_max" ).x, 1.0 )
self.assertEqual( arnold.AiNodeGetVec2( n, "screen_window_max" ).y, 1.0 )
def testConvert( self ) : s = IECore.SpherePrimitive( 0.25 ) with IECoreArnold.UniverseBlock() : n = IECoreArnold.NodeAlgo.convert( s ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "sphere" ) self.assertEqual( arnold.AiNodeGetFlt( n, "radius" ), 0.25 )
def testConvert( self ) : s = IECoreScene.SpherePrimitive( 0.25 ) with IECoreArnold.UniverseBlock( writable = True ) as universe : n = IECoreArnold.NodeAlgo.convert( s, universe, "testSphere" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "sphere" ) self.assertEqual( arnold.AiNodeGetFlt( n, "radius" ), 0.25 )
def testThreading(self):
with IECoreArnold.UniverseBlock(writable=True):
converter = IECoreArnold.InstancingConverter()
meshes = []
for i in range(0, 1000):
meshes.append(
IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-i), IECore.V2f(i))))
def f(nodeList):
for i in range(0, 10000):
nodeList.append(
converter.convert(random.choice(meshes), "testMesh"))
nodeLists = []
threads = []
for i in range(0, 10):
nodeList = []
nodeLists.append(nodeList)
t = threading.Thread(target=f, args=(nodeList, ))
threads.append(t)
t.start()
for t in threads:
t.join()
numPolyMeshNodes = 0
numInstanceNodes = 0
polyMeshAddresses = set()
instancedNodeAddresses = []
for nodeList in nodeLists:
self.assertEqual(len(nodeList), 10000)
for node in nodeList:
nodeType = arnold.AiNodeEntryGetName(
arnold.AiNodeGetNodeEntry(node))
self.failUnless(nodeType in ("ginstance", "polymesh"))
if nodeType == "ginstance":
numInstanceNodes += 1
instancedNodeAddresses.append(
arnold.AiNodeGetPtr(node, "node"))
else:
numPolyMeshNodes += 1
polyMeshAddresses.add(ctypes.addressof(node.contents))
self.assertEqual(numInstanceNodes + numPolyMeshNodes, 10000 * 10)
for address in instancedNodeAddresses:
self.failUnless(address in polyMeshAddresses)
def __allNodes( self, type = arnold.AI_NODE_ALL, ignoreRoot = True ) : result = [] i = arnold.AiUniverseGetNodeIterator( type ) while not arnold.AiNodeIteratorFinished( i ) : node = arnold.AiNodeIteratorGetNext( i ) if ignoreRoot and arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( node ) ) == "list_aggregate" and arnold.AiNodeGetName( node ) == "root" : continue result.append( node ) return result
def testMotion(self):
with IECoreArnold.UniverseBlock(writable=True):
c = IECoreArnold.InstancingConverter()
m1 = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-1), IECore.V2f(1)))
m2 = IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-2), IECore.V2f(2)))
n1 = c.convert([m1, m2], -0.25, 0.25, "testMesh")
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n1)),
"polymesh")
self.assertEqual(
arnold.AiArrayGetNumKeys(
arnold.AiNodeGetArray(n1, "vlist").contents), 2)
n2 = c.convert([m1, m2], -0.25, 0.25, "testInstance")
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n2)),
"ginstance")
self.assertEqual(arnold.AiNodeGetPtr(n2, "node"),
ctypes.addressof(n1.contents))
n3 = c.convert([m2, m1], -0.25, 0.25, "testMesh")
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n1)),
"polymesh")
self.assertEqual(
arnold.AiArrayGetNumKeys(
arnold.AiNodeGetArray(n1, "vlist").contents), 2)
n4 = c.convert([m1, m2], -0.5, 0.5, "testInstance")
self.assertEqual(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n1)),
"polymesh")
self.assertEqual(
arnold.AiArrayGetNumKeys(
arnold.AiNodeGetArray(n1, "vlist").contents), 2)
def testConvertWithMotion( self ) : s = [ IECore.SpherePrimitive( 0.25 ), IECore.SpherePrimitive( 0.5 ) ] with IECoreArnold.UniverseBlock( writable = True ) : n = IECoreArnold.NodeAlgo.convert( s, 0, 1, "testSphere" ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "sphere" ) a = arnold.AiNodeGetArray( n, "radius" ) self.assertEqual( arnold.AiArrayGetFlt( a, 0 ), 0.25 ) self.assertEqual( arnold.AiArrayGetFlt( a, 1 ), 0.5 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_start" ), 0 ) self.assertEqual( arnold.AiNodeGetFlt( n, "motion_end" ), 1 )
def testConvertWithMotion( self ) : s = [ IECore.SpherePrimitive( 0.25 ), IECore.SpherePrimitive( 0.5 ) ] with IECoreArnold.UniverseBlock() : n = IECoreArnold.NodeAlgo.convert( s, [ 0, 1 ] ) self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "sphere" ) a = arnold.AiNodeGetArray( n, "radius" ) self.assertEqual( arnold.AiArrayGetFlt( a, 0 ), 0.25 ) self.assertEqual( arnold.AiArrayGetFlt( a, 1 ), 0.5 ) a = arnold.AiNodeGetArray( n, "deform_time_samples" ) self.assertEqual( arnold.AiArrayGetFlt( a, 0 ), 0 ) self.assertEqual( arnold.AiArrayGetFlt( a, 1 ), 1 )
def testConvertCustomProjection(self):
with IECoreArnold.UniverseBlock(writable=True):
n = IECoreArnold.NodeAlgo.convert(
IECoreScene.Camera(
parameters={
"projection": "cyl_camera",
"horizontal_fov": 45.0,
"vertical_fov": 80.0,
}), "testCamera")
self.assertTrue(
arnold.AiNodeEntryGetName(arnold.AiNodeGetNodeEntry(n)),
"cyl_camera")
self.assertEqual(arnold.AiNodeGetFlt(n, "horizontal_fov"), 45.0)
self.assertEqual(arnold.AiNodeGetFlt(n, "vertical_fov"), 80.0)
def testDisabling( self ) : r = IECoreArnold.Renderer() with IECore.WorldBlock( r ) : r.setAttribute( "ai:automaticInstancing", IECore.BoolData( False ) ) m = IECore.MeshPrimitive.createPlane( IECore.Box2f( IECore.V2f( -1 ), IECore.V2f( 1 ) ) ) m.render( r ) m.render( r ) nodes = self.__allNodes( type = arnold.AI_NODE_SHAPE ) self.assertEqual( len( nodes ), 2 ) nodeTypes = [ arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ) for n in nodes ] self.assertEqual( nodeTypes, [ "polymesh", "polymesh" ] )
def testProcedural( self ) :
r = IECoreArnold.Renderer( "/tmp/test.ass" )
with IECore.WorldBlock( r ) :
# In Arnold 5, external procedurals register node types that look just like the built-in
# ones. So we need to be able to use ExternalProcedural to create an arbitrary node type,
# instead of passing in a filename. Test with a volume, because this node type exists by default.
r.procedural(
r.ExternalProcedural(
"volume",
IECore.Box3f( IECore.V3f( -1, -2, -3 ), IECore.V3f( 4, 5, 6 ) ),
{
"testFloat" : 0.5
}
)
)
volume = self.__allNodes( type = arnold.AI_NODE_SHAPE )[-1]
self.assertEqual( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( volume ) ), "volume" )
self.assertEqual( arnold.AiNodeGetFlt( volume, "testFloat" ), 0.5 )
def testConvertPerspective( self ) :
with IECoreArnold.UniverseBlock( writable = True ) :
c = IECoreScene.Camera(
parameters = {
"projection" : "perspective",
"focalLength" : 1 / ( 2.0 * math.tan( 0.5 * math.radians( 45 ) ) ),
"resolution" : imath.V2i( 512 ),
"aperture" : imath.V2f( 2, 1 )
}
)
n = IECoreArnold.NodeAlgo.convert( c, "testCamera" )
screenWindow = c.frustum()
self.assertTrue( arnold.AiNodeEntryGetName( arnold.AiNodeGetNodeEntry( n ) ), "persp_camera" )
screenWindowMult = math.tan( 0.5 * math.radians( arnold.AiNodeGetFlt( n, "fov" ) ) )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).x, screenWindow.min()[0] )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_min" ).y, screenWindow.min()[1] )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).x, screenWindow.max()[0] )
self.assertAlmostEqual( screenWindowMult * arnold.AiNodeGetVec2( n, "screen_window_max" ).y, screenWindow.max()[1] )
def testSceneDescription(self):
r = GafferScene.Private.IECoreScenePreview.Renderer.create(
"IECoreArnold::Renderer", GafferScene.Private.IECoreScenePreview.
Renderer.RenderType.SceneDescription,
self.temporaryDirectory() + "/test.ass")
o = r.object(
"testPlane",
IECore.MeshPrimitive.createPlane(
IECore.Box2f(IECore.V2f(-1), IECore.V2f(1))))
o.transform(IECore.M44f().translate(IECore.V3f(1, 2, 3)))
r.render()
del r
with IECoreArnold.UniverseBlock():
arnold.AiASSLoad(self.temporaryDirectory() + "/test.ass")
n = arnold.AiNodeLookUpByName("testPlane")
self.assertTrue(
arnold.AiNodeEntryGetType(arnold.AiNodeGetNodeEntry(n)),
arnold.AI_NODE_SHAPE)
def GetNode(user_data, i):
ptype, pval = user_data.get("type")
n = arnold.AiNode(pval)
if n:
name = "sample_%s" % pval
arnold.AiNodeSetStr(n, "name", name)
ne = arnold.AiNodeGetNodeEntry(n)
for k, v in user_data.iteritems():
if k == "type":
continue
ptype, pval = v
pe = arnold.AiNodeEntryLookUpParameter(ne, k)
if pe:
if ptype == arnold.AI_TYPE_BOOLEAN:
arnold.AiNodeSetBool(n, k, pval)
elif ptype == arnold.AI_TYPE_INT:
arnold.AiNodeSetInt(n, k, pval)
elif ptype == arnold.AI_TYPE_UINT:
arnold.AiNodeSetUInt(n, k, pval)
elif ptype == arnold.AI_TYPE_FLOAT:
arnold.AiNodeSetFlt(n, k, pval)
elif ptype == arnold.AI_TYPE_POINT:
arnold.AiNodeSetPnt(n, k, pval.x, pval.y, pval.z)
elif ptype == arnold.AI_TYPE_POINT2:
arnold.AiNodeSetPnt2(n, k, pval.x, pval.y)
elif ptype == arnold.AI_TYPE_VECTOR:
arnold.AiNodeSetVec(n, k, pval.x, pval.y, pval.z)
elif ptype == arnold.AI_TYPE_RGB:
arnold.AiNodeSetRGB(n, k, pval.r, pval.g, pval.b)
elif ptype == arnold.AI_TYPE_RGBA:
arnold.AiNodeSetRGBA(n, k, pval.r, pval.g, pval.b, pval.a)
elif ptype == arnold.AI_TYPE_STRING:
arnold.AiNodeSetStr(n, k, pval)
return name
else:
return None
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 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))
