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 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 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 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 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 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 appendShaders(menuDefinition, prefix="/Arnold"):
with IECoreArnold.UniverseBlock():
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("_")])
if arnold.AiNodeEntryGetType(nodeEntry) == arnold.AI_NODE_SHADER:
menuPath = prefix + "/Shader/" + displayName
nodeType = GafferArnold.ArnoldShader
else:
menuPath = prefix + "/Light/" + displayName
nodeType = GafferArnold.ArnoldLight
menuDefinition.append(
menuPath, {
"command":
GafferUI.NodeMenu.nodeCreatorWrapper(
IECore.curry(__shaderCreator, shaderName, nodeType)),
})
arnold.AiNodeEntryIteratorDestroy(it)
arnold.AiEnd()
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 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 __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 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 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 __walkHoudiniParameters(nodeEntry, parameters, sectionName):
nodeName = arnold.AiNodeEntryGetName(nodeEntry)
# Iterate over our parameters, recursing if we
# hit new sections, and adding metadata to regular
# parameters.
sectionNameWithHeading = sectionName
parameterIndex = 0
while parameterIndex < len(parameters):
parameter = parameters[parameterIndex]
parameterIndex += 1
if parameter.type == "folder":
# A folder is actually a tab bar, grouping
# parameters into different tabs below it.
# It is specified as a series of NAME;N; pairs
# in a string, where NAME is the name of a tab,
# and N is how many parameters it should include.
tabs = parameter.contents.strip(";").split(";")
for tabName, tabSize in [(tabs[i], int(tabs[i + 1]))
for i in range(0, len(tabs), 2)]:
tabSectionName = sectionNameWithHeading + (
"." if sectionNameWithHeading else "") + tabName
__walkHoudiniParameters(
nodeEntry,
parameters[parameterIndex:parameterIndex + tabSize],
tabSectionName)
parameterIndex += tabSize
elif parameter.type == "heading":
# A heading is a horizontal rule with a label.
# We don't have those, so we map them to a
# 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
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 testLoadAllLightsWithoutWarnings( self ) : lightNames = [] with IECoreArnold.UniverseBlock( writable = False ) : it = arnold.AiUniverseGetNodeEntryIterator( arnold.AI_NODE_LIGHT ) while not arnold.AiNodeEntryIteratorFinished( it ) : nodeEntry = arnold.AiNodeEntryIteratorGetNext( it ) lightNames.append( arnold.AiNodeEntryGetName( nodeEntry ) ) self.longMessage = True for lightName in lightNames : with IECore.CapturingMessageHandler() as mh : l = GafferArnold.ArnoldLight() l.loadShader( lightName ) self.assertEqual( [ m.message for m in mh.messages ], [], "Error loading %s" % lightName )
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] )
'''
ai.AiBegin()
entryList = [] # list of [nodeEntryName, nodeEntryTypeName, parametersList ]
entryByType = {
} # dictionary (key= nodeEntryTypeName, value=list of nodeEntryName for this type)
typeParams = {
} # dictionary (key=nodeEntryTypeName, value= list of parameters which exist in ALL the corresponding nodeEntryName)
# Loop over node entries
nodeEntryIter = ai.AiUniverseGetNodeEntryIterator(ai.AI_NODE_ALL)
while not ai.AiNodeEntryIteratorFinished(nodeEntryIter):
nentry = ai.AiNodeEntryIteratorGetNext(nodeEntryIter)
# Name of this AtNodeEntry (distant_light, skydome_light, etc...)
entryName = str(ai.AiNodeEntryGetName(nentry))
# Type of this AtNodeEntry (light, shape, shader, operator, etc...)
entryTypeName = str(ai.AiNodeEntryGetTypeName(nentry))
# we don't want to create schemas for shaders, as we're relying on UsdShade schemas
if entryTypeName == 'shader':
continue
# Get the list of parameters for this node entry
paramsList = []
# Loop over AtParamEntry for this AtNodeEntry
paramsIter = ai.AiNodeEntryGetParamIterator(nentry)
while not ai.AiParamIteratorFinished(paramsIter):
paramEntry = ai.AiParamIteratorGetNext(paramsIter)
# Add this parameter name to our list
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"
if shaderName == "light_blocker":
nodeCreator = functools.partial(
__shaderCreator, shaderName,
GafferArnold.ArnoldLightFilter)
else:
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 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 __translateNodeMetadata(nodeEntry):
nodeName = arnold.AiNodeEntryGetName(nodeEntry)
# Shader description. We support Arnold-style "desc" and
# OSL style "help".
description = __aiMetadataGetStr(nodeEntry,
None,
"desc",
defaultValue=__aiMetadataGetStr(
nodeEntry, None, "help"))
if description is not None:
__metadata[nodeName]["description"] = description
# Documentation URL. We support OSL-style "URL"
url = __aiMetadataGetStr(nodeEntry, None, "URL")
if url is not None:
__metadata[nodeName]["documentation:url"] = url
havePages = False
paramIt = arnold.AiNodeEntryGetParamIterator(nodeEntry)
while not arnold.AiParamIteratorFinished(paramIt):
## \todo We could allow custom ui types to be specified using
# arnold metadata entries.
param = arnold.AiParamIteratorGetNext(paramIt)
paramName = arnold.AiParamGetName(param)
paramPath = nodeName + ".parameters." + paramName
# Parameter description
description = __aiMetadataGetStr(nodeEntry, paramName, "desc")
if description is not None:
__metadata[paramPath]["description"] = description
# Parameter presets from enum values
paramType = arnold.AiParamGetType(param)
if paramType == arnold.AI_TYPE_ENUM:
enum = arnold.AiParamGetEnum(param)
presets = IECore.StringVectorData()
while True:
preset = arnold.AiEnumGetString(enum, len(presets))
if not preset:
break
presets.append(preset)
__metadata[paramPath][
"plugValueWidget:type"] = "GafferUI.PresetsPlugValueWidget"
__metadata[paramPath]["presetNames"] = presets
__metadata[paramPath]["presetValues"] = presets
# Nodule type from linkable metadata and parameter type
linkable = __aiMetadataGetBool(
nodeEntry,
paramName,
"linkable",
defaultValue=paramType
not in (arnold.AI_TYPE_BYTE, arnold.AI_TYPE_INT,
arnold.AI_TYPE_UINT, arnold.AI_TYPE_BOOLEAN,
arnold.AI_TYPE_ENUM, arnold.AI_TYPE_STRING))
__metadata[paramPath][
"nodule:type"] = "GafferUI::StandardNodule" if linkable else ""
# PlugValueWidget type from OSL "widget"
widget = None
widget = __aiMetadataGetStr(nodeEntry, paramName, "widget", widget)
if widget is not None:
__metadata[paramPath]["plugValueWidget:type"] = {
"number": "GafferUI.NumericPlugValueWidget",
"string": "GafferUI.StringPlugValueWidget",
"boolean": "GafferUI.BoolPlugValueWidget",
"checkBox": "GafferUI.BoolPlugValueWidget",
"popup": "GafferUI.PresetsPlugValueWidget",
"mapper": "GafferUI.PresetsPlugValueWidget",
"filename": "GafferUI.PathPlugValueWidget",
"null": "",
}[widget]
# Layout section from OSL "page".
page = __aiMetadataGetStr(nodeEntry, paramName, "page")
if page is not None:
havePages = True
__metadata[paramPath]["layout:section"] = page
# Label from OSL "label"
label = __aiMetadataGetStr(nodeEntry, paramName, "label")
if label is not None:
__metadata[paramPath]["label"] = label
elif "_" in paramName:
# Label from Arnold naming convention
# Arnold uses snake_case rather than camelCase for naming, so translate this into
# 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
########################################################################## # Build a registry of information retrieved from Arnold metadata. We fill this # once at startup, as we can only get it from within an AiUniverse block, # and we don't want to have to keep making those temporarily later. ########################################################################## __metadata = collections.defaultdict( dict ) with IECoreArnold.UniverseBlock() : nodeIt = arnold.AiUniverseGetNodeEntryIterator( arnold.AI_NODE_SHADER | arnold.AI_NODE_LIGHT ) while not arnold.AiNodeEntryIteratorFinished( nodeIt ) : nodeEntry = arnold.AiNodeEntryIteratorGetNext( nodeIt ) nodeName = arnold.AiNodeEntryGetName( nodeEntry ) description = __aiMetadataGetStr( nodeEntry, None, "desc" ) if description is not None : __metadata[nodeName]["description"] = description paramIt = arnold.AiNodeEntryGetParamIterator( nodeEntry ) while not arnold.AiParamIteratorFinished( paramIt ) : ## \todo We could allow custom ui types to be specified using # arnold metadata entries. param = arnold.AiParamIteratorGetNext( paramIt ) paramName = arnold.AiParamGetName( param ) paramPath = nodeName + "." + paramName description = __aiMetadataGetStr( nodeEntry, paramName, "desc" )
def __translateNodeMetadata(nodeEntry):
nodeName = arnold.AiNodeEntryGetName(nodeEntry)
# Shader description. We support Arnold-style "desc" and
# OSL style "help".
description = __aiMetadataGetStr(nodeEntry,
None,
"desc",
defaultValue=__aiMetadataGetStr(
nodeEntry, None, "help"))
if description is not None:
__metadata[nodeName]["description"] = description
# Documentation URL. We support OSL-style "URL"
url = __aiMetadataGetStr(nodeEntry, None, "URL")
if url is not None:
__metadata[nodeName]["documentation:url"] = url
# Icon. There doesn't appear to be a standard for this, so
# we support "gaffer.icon" and "gaffer.iconScale".
icon = __aiMetadataGetStr(nodeEntry, None, "gaffer.icon")
if icon is not None:
__metadata[nodeName]["icon"] = icon
iconScale = __aiMetadataGetFlt(nodeEntry, None, "gaffer.iconScale")
if iconScale is not None:
__metadata[nodeName]["iconScale"] = iconScale
paramIt = arnold.AiNodeEntryGetParamIterator(nodeEntry)
while not arnold.AiParamIteratorFinished(paramIt):
## \todo We could allow custom ui types to be specified using
# arnold metadata entries.
param = arnold.AiParamIteratorGetNext(paramIt)
paramName = arnold.AiParamGetName(param)
paramPath = nodeName + ".parameters." + paramName
paramType = arnold.AiParamGetType(param)
# Parameter description
description = __aiMetadataGetStr(nodeEntry, paramName, "desc")
if description is not None:
__metadata[paramPath]["description"] = description
# Presets
if paramType == arnold.AI_TYPE_ENUM:
# Parameter presets from enum values
presetValues = __enumPresetValues(param)
presetNames = presetValues
else:
# Manually specified presets for other types
presetValues = __plugPresetValues(nodeEntry, paramName, paramType)
presetNames = __plugPresetNames(nodeEntry, paramName)
if presetValues:
__metadata[paramPath][
"plugValueWidget:type"] = "GafferUI.PresetsPlugValueWidget"
__metadata[paramPath]["presetValues"] = presetValues
__metadata[paramPath]["presetNames"] = presetNames
# Nodule type from linkable metadata and parameter type
linkable = __aiMetadataGetBool(
nodeEntry,
paramName,
"linkable",
defaultValue=paramType
not in (arnold.AI_TYPE_BYTE, arnold.AI_TYPE_INT,
arnold.AI_TYPE_UINT, arnold.AI_TYPE_BOOLEAN,
arnold.AI_TYPE_ENUM, arnold.AI_TYPE_STRING))
__metadata[paramPath]["nodule:type"] = None if linkable else ""
# PlugValueWidget type from OSL "widget"
widget = None
widget = __aiMetadataGetStr(nodeEntry, paramName, "widget", widget)
if widget is not None:
__metadata[paramPath]["plugValueWidget:type"] = {
"number": "GafferUI.NumericPlugValueWidget",
"string": "GafferUI.StringPlugValueWidget",
"boolean": "GafferUI.BoolPlugValueWidget",
"checkBox": "GafferUI.BoolPlugValueWidget",
"popup": "GafferUI.PresetsPlugValueWidget",
"mapper": "GafferUI.PresetsPlugValueWidget",
"filename": "GafferUI.PathPlugValueWidget",
"null": "",
}[widget]
# Layout section from OSL "page".
page = __aiMetadataGetStr(nodeEntry, paramName, "page")
if page is not None:
__metadata[paramPath]["layout:section"] = page
# Uncollapse sections if desired
collapsed = __aiMetadataGetBool(
nodeEntry, None, "gaffer.layout.section.%s.collapsed" % page)
if collapsed == False:
parent = paramPath.rsplit('.', 1)[0]
__metadata[parent]["layout:section:%s:collapsed" %
page] = collapsed
# Label from OSL "label"
label = __aiMetadataGetStr(nodeEntry, paramName, "label")
if label is None:
# Label from Arnold naming convention
# Arnold uses snake_case rather than camelCase for naming, so translate this into
# nice looking names
label = " ".join([i.capitalize() for i in paramName.split("_")])
__metadata[paramPath]["label"] = label
__metadata[paramPath]["noduleLayout:label"] = label
childComponents = {
arnold.AI_TYPE_VECTOR2: "xy",
arnold.AI_TYPE_VECTOR: "xyz",
arnold.AI_TYPE_RGB: "rgb",
arnold.AI_TYPE_RGBA: "rgba",
}.get(paramType)
if childComponents is not None:
for c in childComponents:
__metadata["{}.{}".format(
paramPath,
c)]["noduleLayout:label"] = "{}.{}".format(label, c)
# NodeEditor layout from other Gaffer-specific metadata
divider = __aiMetadataGetBool(nodeEntry, paramName,
"gaffer.layout.divider")
if divider:
__metadata[paramPath]["layout:divider"] = True
index = __aiMetadataGetInt(nodeEntry, paramName, "gaffer.layout.index")
if index is not None:
__metadata[paramPath]["layout:index"] = index
# GraphEditor visibility from Gaffer-specific metadata
visible = __aiMetadataGetBool(
nodeEntry, None, "gaffer.graphEditorLayout.defaultVisibility")
visible = __aiMetadataGetBool(nodeEntry, paramName,
"gaffer.graphEditorLayout.visible",
visible)
if visible is not None:
__metadata[paramPath]["noduleLayout:visible"] = visible
userDefault = None
if paramType in [
arnold.AI_TYPE_BYTE, arnold.AI_TYPE_INT, arnold.AI_TYPE_UINT
]:
userDefault = __aiMetadataGetInt(nodeEntry, paramName,
"gaffer.userDefault")
elif paramType == arnold.AI_TYPE_BOOLEAN:
userDefault = __aiMetadataGetBool(nodeEntry, paramName,
"gaffer.userDefault")
elif paramType == arnold.AI_TYPE_FLOAT:
userDefault = __aiMetadataGetFlt(nodeEntry, paramName,
"gaffer.userDefault")
elif paramType == arnold.AI_TYPE_RGB:
userDefault = __aiMetadataGetRGB(nodeEntry, paramName,
"gaffer.userDefault")
#elif paramType == arnold.AI_TYPE_RGBA:
# userDefault = __aiMetadataGetRGBA( nodeEntry, paramName, "gaffer.userDefault" )
elif paramType == arnold.AI_TYPE_VECTOR:
userDefault = __aiMetadataGetVec(nodeEntry, paramName,
"gaffer.userDefault")
elif paramType == arnold.AI_TYPE_VECTOR2:
userDefault = __aiMetadataGetVec2(nodeEntry, paramName,
"gaffer.userDefault")
elif paramType == arnold.AI_TYPE_STRING:
userDefault = __aiMetadataGetStr(nodeEntry, paramName,
"gaffer.userDefault")
elif paramType == arnold.AI_TYPE_ENUM:
userDefault = __aiMetadataGetStr(nodeEntry, paramName,
"gaffer.userDefault")
if userDefault:
nodeName, _, plugName = paramPath.split(".")
Gaffer.Metadata.registerValue(
"ai:surface:%s:%s" % (nodeName, plugName), "userDefault",
userDefault)
