Пример #1
0
	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 ) )
Пример #2
0
    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))
Пример #3
0
    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")
Пример #4
0
    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)
Пример #5
0
    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)
Пример #6
0
	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" )