コード例 #1
0
	def testReferenceExistingShader( self ) :
	
		r = IECoreArnold.Renderer()
		
		r.display( "test", "ieDisplay", "rgba", { "driverType" : "ImageDisplayDriver", "handle" : "test" } )

		with IECore.WorldBlock( r ) :
		
			shader = arnold.AiNode( "standard" )
			arnold.AiNodeSetStr( shader, "name", "red_shader" )
			arnold.AiNodeSetFlt( shader, "emission", 1 )
			arnold.AiNodeSetRGB( shader, "emission_color", 1, 0, 0 )
			
			r.shader( "surface", "reference:red_shader", {} )
			r.sphere( 1, -1, 1, 360, {} )

		image = IECore.ImageDisplayDriver.removeStoredImage( "test" )

		e = IECore.PrimitiveEvaluator.create( image )
		result = e.createResult()
		e.pointAtUV( IECore.V2f( 0.5, 0.5 ), result )
		self.assertAlmostEqual( result.floatPrimVar( e.A() ), 1, 5 )
		self.assertAlmostEqual( result.floatPrimVar( e.R() ), 1, 5 )
		self.assertEqual( result.floatPrimVar( e.G() ), 0 )
		self.assertEqual( result.floatPrimVar( e.B() ), 0 )	
コード例 #2
0
    def testReferenceExistingShader(self):

        r = IECoreArnold.Renderer()

        r.display("test", "ieDisplay", "rgba", {
            "driverType": "ImageDisplayDriver",
            "handle": "test"
        })

        with IECore.WorldBlock(r):

            shader = arnold.AiNode("standard")
            arnold.AiNodeSetStr(shader, "name", "red_shader")
            arnold.AiNodeSetFlt(shader, "emission", 1)
            arnold.AiNodeSetRGB(shader, "emission_color", 1, 0, 0)

            r.shader("surface", "reference:red_shader", {})
            r.sphere(1, -1, 1, 360, {})

        image = IECoreImage.ImageDisplayDriver.removeStoredImage("test")

        dimensions = image.dataWindow.size() + IECore.V2i(1)
        index = dimensions.x * int(dimensions.y * 0.5) + int(
            dimensions.x * 0.5)
        self.assertAlmostEqual(image["A"][index], 1, 5)
        self.assertAlmostEqual(image["R"][index], 1, 5)
        self.assertEqual(image["G"][index], 0)
        self.assertEqual(image["B"][index], 0)
コード例 #3
0
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
コード例 #4
0
ファイル: ipr.py プロジェクト: lvxejay/barnold
def _worker(data, new_data, redraw_event, mmap_size, mmap_name, state):
    print("+++ _worker: started")

    import os
    import ctypes

    dir = os.path.dirname(__file__)
    if dir not in sys.path:
        sys.path.append(dir)

    import arnold

    nodes = {}
    lights = {}
    nptrs = []  # nodes linked by AiNodeSetPtr
    links = []  # nodes linked by AiNodeLink

    def _AiNodeSetArray(node, param, value):
        t, a = value
        _len = len(a)
        if t == arnold.AI_TYPE_VECTOR:
            _len //= 3
        elif t == arnold.AI_TYPE_UINT:
            pass
        _a = arnold.AiArrayConvert(_len, 1, t, ctypes.c_void_p(a.ctypes.data))
        arnold.AiNodeSetArray(node, param, _a)

    _AiNodeSet = {
        'NodeSocketShader': lambda n, i, v: True,
        'NodeSocketBool': lambda n, i, v: arnold.AiNodeSetBool(n, i, v),
        'NodeSocketInt': lambda n, i, v: arnold.AiNodeSetInt(n, i, v),
        'NodeSocketFloat': lambda n, i, v: arnold.AiNodeSetFlt(n, i, v),
        'NodeSocketColor': lambda n, i, v: arnold.AiNodeSetRGBA(n, i, *v),
        'NodeSocketVector': lambda n, i, v: arnold.AiNodeSetVec(n, i, *v),
        'NodeSocketVectorXYZ':
        lambda n, i, v: arnold.AiNodeSetVector(n, i, *v),
        'NodeSocketString': lambda n, i, v: arnold.AiNodeSetStr(n, i, v),
        'ArnoldNodeSocketColor': lambda n, i, v: arnold.AiNodeSetRGB(n, i, *v),
        'ArnoldNodeSocketByte': lambda n, i, v: arnold.AiNodeSetByte(n, i, v),
        'ArnoldNodeSocketProperty': lambda n, i, v: True,
        'BOOL': lambda n, p, v: arnold.AiNodeSetBool(n, p, v),
        'BYTE': lambda n, p, v: arnold.AiNodeSetByte(n, p, v),
        'INT': lambda n, p, v: arnold.AiNodeSetInt(n, p, v),
        'FLOAT': lambda n, p, v: arnold.AiNodeSetFlt(n, p, v),
        'VECTOR2': lambda n, p, v: arnold.AiNodeSetVec2(n, p, *v),
        'RGB': lambda n, p, v: arnold.AiNodeSetRGB(n, p, *v),
        'RGBA': lambda n, p, v: arnold.AiNodeSetRGBA(n, p, *v),
        'VECTOR': lambda n, p, v: arnold.AiNodeSetVec(n, p, *v),
        'STRING': lambda n, p, v: arnold.AiNodeSetStr(n, p, v),
        'MATRIX':
        lambda n, p, v: arnold.AiNodeSetMatrix(n, p, arnold.AtMatrix(*v)),
        'ARRAY': _AiNodeSetArray,
        'LINK': lambda n, p, v: links.append((n, p, v)),
        'NODE': lambda n, p, v: nptrs.append((n, p, v)),
    }

    arnold.AiBegin()
    try:
        # arnold.AiMsgSetConsoleFlags(arnold.AI_LOG_ALL)
        # arnold.AiMsgSetConsoleFlags(0x000E)
        #
        # from pprint import pprint as pp
        # pp(data)

        ## Nodes
        for node in data['nodes']:
            nt, np = node
            anode = arnold.AiNode(nt)
            for n, (t, v) in np.items():
                _AiNodeSet[t](anode, n, v)
            nodes[id(node)] = anode
        for light in data['lights']:
            nt, np = light
            anode = arnold.AiNode(nt)
            for n, (t, v) in np.items():
                _AiNodeSet[t](anode, n, v)
            lights[id(light)] = anode
        options = arnold.AiUniverseGetOptions()
        for n, (t, v) in data['options'].items():
            _AiNodeSet[t](options, n, v)
        for n, p, v in nptrs:
            arnold.AiNodeSetPtr(n, p, nodes[id(v)])
        for n, p, v in links:
            arnold.AiNodeLink(nodes[id(v)], p, n)

        ## Outputs
        filter = arnold.AiNode("gaussian_filter")
        arnold.AiNodeSetStr(filter, "name", "__filter")
        driver = arnold.AiNode("driver_display_callback")
        arnold.AiNodeSetStr(driver, "name", "__driver")
        #arnold.AiNodeSetBool(driver, "rgba_packing", False)
        outputs_aovs = (b"RGBA RGBA __filter __driver", )
        outputs = arnold.AiArray(len(outputs_aovs), 1, arnold.AI_TYPE_STRING,
                                 *outputs_aovs)
        arnold.AiNodeSetArray(options, "outputs", outputs)

        sl = data['sl']

        del nodes, nptrs, links, data

        if platform.system() == "Darwin" or "Linux":
            _rect = lambda w, h: numpy.frombuffer(mmap.mmap(-1, w * h * 4 * 4),
                                                  dtype=numpy.float32).reshape(
                                                      [h, w, 4])
            rect = _rect(*mmap_size)

        if platform.system() == "Windows":
            _rect = lambda n, w, h: numpy.frombuffer(
                mmap.mmap(-1, w * h * 4 * 4, n), dtype=numpy.float32).reshape(
                    [h, w, 4])
            rect = _rect(mmap_name, *mmap_size)

        def _callback(x, y, width, height, buffer, data):
            #print("+++ _callback:", x, y, width, height, ctypes.cast(buffer, ctypes.c_void_p))
            if buffer:
                try:
                    if new_data.poll():
                        arnold.AiRenderInterrupt()
                    else:
                        #print("+++ _callback: tile", x, y, width, height)
                        _buffer = ctypes.cast(buffer,
                                              ctypes.POINTER(ctypes.c_uint16))
                        a = numpy.ctypeslib.as_array(_buffer,
                                                     shape=(height, width, 4))
                        rect[y:y + height, x:x + width] = a
                        redraw_event.set()
                    return
                finally:
                    arnold.AiFree(buffer)
            elif not new_data.poll():
                return
            arnold.AiRenderAbort()
            print("+++ _callback: abort")

        cb = arnold.AtDisplayCallBack(_callback)
        arnold.AiNodeSetPtr(driver, "callback", cb)

        class _Dict(dict):
            def update(self, u):
                for k, v in u.items():
                    if isinstance(v, dict):
                        self[k] = _Dict.update(self.get(k, {}), v)
                    else:
                        self[k] = u[k]
                return self

        while state.value != ABORT:
            for _sl in range(*sl):
                arnold.AiNodeSetInt(options, "AA_samples", _sl)
                res = arnold.AiRender(arnold.AI_RENDER_MODE_CAMERA)
                if res == arnold.AI_SUCCESS:
                    break
            if state.value == ABORT:
                #print("+++ _worker: abort")
                break

            data = _Dict()
            _data = new_data.recv()
            print(_data)
            while _data is not None:
                # from pprint import pprint as pp
                # print("+++ _worker: data")
                # pp(_data)
                data.update(_data)
                if not new_data.poll():
                    _nodes = data.get('nodes')
                    if _nodes is not None:
                        for name, params in _nodes.items():
                            node = arnold.AiNodeLookUpByName(name)
                            for n, (t, v) in params.items():
                                _AiNodeSet[t](node, n, v)
                    opts = data.get('options')
                    if opts is not None:
                        for n, (t, v) in opts.items():
                            _AiNodeSet[t](options, n, v)
                    size = data.get('mmap_size')
                    if size is not None:
                        rect = _rect(mmap_name, *size)
                    break
                _data = new_data.recv()
    finally:
        arnold.AiEnd()
    print("+++ _worker: finished")
コード例 #5
0
 def set_rgb(self, param, r, g, b):
     if self.is_valid():
         arnold.AiNodeSetRGB(self.data, param, r, g, b)
コード例 #6
0
    def renderGeo(self):

        arnold.AiBegin()

        arnold.AiMsgSetLogFileName(self._logFile)
        arnold.AiMsgSetConsoleFlags(arnold.AI_LOG_ALL)

        # create a sphere geometric primitive
        sph = arnold.AiNode("sphere")
        arnold.AiNodeSetStr(sph, "name", "mysphere")
        arnold.AiNodeSetVec(sph, "center", 0.0, 4.0, 0.0)
        arnold.AiNodeSetFlt(sph, "radius", 5.0)

        # create a red standard shader
        shader1 = arnold.AiNode("standard")
        arnold.AiNodeSetStr(shader1, "name", "myshader1")
        arnold.AiNodeSetRGB(shader1, "Kd_color", self._color[0],
                            self._color[1], self._color[2])
        arnold.AiNodeSetFlt(shader1, "Ks", 0.05)

        # assign the shaders to the geometric objects
        arnold.AiNodeSetPtr(sph, "shader", shader1)

        # create a perspective camera
        camera = arnold.AiNode("persp_camera")
        arnold.AiNodeSetStr(camera, "name", "mycamera")
        # position the camera (alternatively you can set 'matrix')
        arnold.AiNodeSetVec(camera, "position", 0.0, 10.0, 35.0)
        arnold.AiNodeSetVec(camera, "look_at", 0.0, 3.0, 0.0)
        arnold.AiNodeSetFlt(camera, "fov", 45.0)

        # create a point light source
        light = arnold.AiNode("point_light")
        arnold.AiNodeSetStr(light, "name", "pointLight_A")
        # // position the light (alternatively use 'matrix')
        arnold.AiNodeSetVec(light, "position", 0.0, 30.0, 0.0)
        arnold.AiNodeSetFlt(light, "intensity", 10.0)
        # alternatively, use 'exposure'
        arnold.AiNodeSetFlt(light, "radius", 4.0)
        # for soft shadows

        # create a point light source
        light = arnold.AiNode("point_light")
        arnold.AiNodeSetStr(light, "name", "pointLight_B")
        # // position the light (alternatively use 'matrix')
        arnold.AiNodeSetVec(light, "position", 0.0, -30.0, 0.0)
        arnold.AiNodeSetFlt(light, "intensity", 10.0)
        # alternatively, use 'exposure'
        arnold.AiNodeSetFlt(light, "radius", 4.0)
        # for soft shadows

        # create a point light source
        light = arnold.AiNode("point_light")
        arnold.AiNodeSetStr(light, "name", "pointLight_C")
        # // position the light (alternatively use 'matrix')
        arnold.AiNodeSetVec(light, "position", 0.0, 4.0, 20.0)
        arnold.AiNodeSetFlt(light, "intensity", 5.0)
        # alternatively, use 'exposure'
        arnold.AiNodeSetFlt(light, "radius", 15.0)
        # for soft shadows

        # // get the global options node and set some options
        options = arnold.AiUniverseGetOptions()
        arnold.AiNodeSetInt(options, "AA_samples", 8)
        arnold.AiNodeSetInt(options, "xres", 480)
        arnold.AiNodeSetInt(options, "yres", 360)
        arnold.AiNodeSetInt(options, "GI_diffuse_depth", 4)
        # // set the active camera (optional, since there is only one camera)
        arnold.AiNodeSetPtr(options, "camera", camera)

        # create an output driver node
        driver = arnold.AiNode("driver_jpeg")
        arnold.AiNodeSetStr(driver, "name", "mydriver")
        arnold.AiNodeSetStr(driver, "filename", self._sceneName)
        arnold.AiNodeSetFlt(driver, "gamma", 2.2)

        # create a gaussian filter node
        filter = arnold.AiNode("gaussian_filter")
        arnold.AiNodeSetStr(filter, "name", "myfilter")

        # assign the driver and filter to the main (beauty) AOV,
        # which is called "RGBA" and is of type RGBA
        outputs_array = arnold.AiArrayAllocate(1, 1, arnold.AI_TYPE_STRING)
        arnold.AiArraySetStr(outputs_array, 0, "RGBA RGBA myfilter mydriver")
        arnold.AiNodeSetArray(options, "outputs", outputs_array)

        # finally, render the image!
        arnold.AiRender(arnold.AI_RENDER_MODE_CAMERA)

        # // Arnold session shutdown
        arnold.AiEnd()