def load(self, shader_name): args = [] text = self._loader.load(shader_name, 'props.txt') if text is not None: args = parse_args(text) w = Vec3Arg('w', self._w) u = Vec3Arg('u', self._u) v = Vec3Arg('v', self._v) distance = FloatArg('distance', self._distance) eye = Vec3Arg('eye', self._eye) lookat = Vec3Arg('lookat', self._lookat) args.extend([w, u, v, distance, eye, lookat]) code = self._loader.load(shader_name, 'code.py') if code is None: raise ValueError("code.py in %s shader dont exist!" % shader_name) func_args = [ StructArgPtr('ray', Ray.factory()), StructArgPtr('sample', Sample.factory()) ] self._shader_name = shader_name self.shader = Shader(code=code, args=args, name='generate_ray', func_args=func_args, is_func=True)
class SampleFilter: def __init__(self, xwidth=1.0, ywidth=1.0): path = os.path.dirname(__file__) path = os.path.join(path, 'flt_shaders') self._loader = Loader([path]) self.xwidth = xwidth self.ywidth = ywidth def load(self, shader_name): args = [] text = self._loader.load(shader_name, 'props.txt') if text is not None: args = parse_args(text) args.append(FloatArg('xwidth', self.xwidth)) args.append(FloatArg('ywidth', self.ywidth)) code = self._loader.load(shader_name, 'code.py') if code is None: raise ValueError("code.py in %s shader dont exist!" % shader_name) func_args = [StructArgPtr('sample', Sample.factory())] self.shader = Shader(code=code, args=args, name='filter_sample', func_args=func_args, is_func=True) def compile(self, shaders=[]): self.shader.compile(shaders) def prepare(self, runtimes): self.shader.prepare(runtimes)
def atest_material_manager(self): sam_mgr = SampledManager() register_rgb_shadepoint() runtimes = [Runtime(), Runtime()] mat = Material() mat.load('lambertian', sam_mgr, spectral=False) mat.set_value('diffuse', RGBSpectrum(0.2, 0.3, 0.4)) mgr = MaterialManager() mgr.add('material1', mat) mgr.compile_shaders(sam_mgr, spectral=False) mgr.prepare_shaders(runtimes) code = """ hp = HitPoint() sp = ShadePoint() material_reflectance(hp, sp, 0) spec = sp.material_reflectance """ spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5)) shader = Shader(code=code, args=[spec]) shader.compile(shaders=[mgr.ref_shader]) shader.prepare(runtimes) shader.execute() s = shader.get_value('spec') ls = RGBSpectrum(0.2, 0.3, 0.4) * (1.0 / math.pi) self.assertAlmostEqual(s.r, ls.r) self.assertAlmostEqual(s.g, ls.g) self.assertAlmostEqual(s.b, ls.b)
def test_sampled_to_rgb(self): runtimes = [Runtime()] color_mgr = SampledManager() s_to_rgb = spectrum_to_rgb_shader(color_mgr) s_to_rgb.compile(color_mgr=color_mgr) s_to_rgb.prepare(runtimes) code = """ value = spectrum_to_rgb(color) """ spec = RGBSpectrum(0.3, 0.5, 0.4) spec = color_mgr.rgb_to_sampled(spec) col = SampledArg('color', spec) val = Vec3Arg('value', Vector3(0.0, 0.0, 0.0)) shader = Shader(code=code, args=[col, val]) shader.compile(shaders=[s_to_rgb], color_mgr=color_mgr) shader.prepare(runtimes) shader.execute() value = shader.get_value('value') vv = color_mgr.sampled_to_rgb(spec) self.assertAlmostEqual(value.x, vv.r) self.assertAlmostEqual(value.y, vv.g) self.assertAlmostEqual(value.z, vv.b, places=6)
def test_isect_b_rect(self): rect_shader = Rectangle.isect_b_shader('isect_b_rectangle') rect_shader.compile() runtimes = [Runtime()] rect_shader.prepare(runtimes) code = """ min_dist = 99999.0 p1 = isect_b_rectangle(ray, rectangle, min_dist) """ origin = Vector3(3.0, 2.5, 0.0) direction = Vector3(0.0, 0.1, 0.88) direction.normalize() ray = Ray(origin, direction) point = Vector3(0.0, 0.0, 55.92) e1 = Vector3(55.28, 0.0, 0.0) e2 = Vector3(0.0, 54.88, 0.0) normal = Vector3(0.0, 0.0, -1.0) rectangle = Rectangle(point, e1, e2, normal) r_arg = StructArg('ray', ray) sph_arg = StructArg('rectangle', rectangle) p1 = IntArg('p1', 6) args = [r_arg, sph_arg, p1] shader = Shader(code=code, args=args) shader.compile([rect_shader.shader]) shader.prepare(runtimes) shader.execute() result = shader.get_value('p1') self.assertEqual(result, 1)
def test_mesh_b(mesh, nrays=1): dep_shader = type(mesh).isect_b_shader('ray_flat_mesh_b_isect') dep_shader.compile() runtimes = [Runtime()] dep_shader.prepare(runtimes) code = """ min_dist = 99999.0 ret = ray_flat_mesh_b_isect(ray, mesh, min_dist) """ origin = calculate_origin(mesh) rpoint = random_in_bbox(mesh._grid.bbox) direction = rpoint - origin direction.normalize() ray = Ray(origin, direction) r_arg = StructArg('ray', ray) mesh_arg = StructArg('mesh', mesh) ret = IntArg('ret', 6) args = [r_arg, mesh_arg, ret] shader = Shader(code=code, args=args) shader.compile([dep_shader.shader]) shader.prepare(runtimes) hp = mesh.isect_b(ray) shader.execute() print("Bool isect", hp, shader.get_value('ret'))
def test_isect_b_sph(self): sph_shader = Sphere.isect_b_shader('isect_b_sphere') sph_shader.compile() runtimes = [Runtime()] sph_shader.prepare(runtimes) code = """ min_dist = 99999.0 p1 = isect_b_sphere(ray, sphere, min_dist) """ direction = Vector3(-1.0, -1.0, -1.0) direction.normalize() ray = Ray(Vector3(5.0, 5.0, 5.0), direction) sphere = Sphere(Vector3(0.0, 0.0, 0.0), 2.0, 0) r_arg = StructArg('ray', ray) sph_arg = StructArg('sphere', sphere) p1 = IntArg('p1', 6) args = [r_arg, sph_arg, p1] shader = Shader(code=code, args=args) shader.compile([sph_shader.shader]) shader.prepare(runtimes) shader.execute() result = shader.get_value('p1') self.assertEqual(result, 1)
class Tmo: def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'shaders') self._loader = Loader([path]) self._shader = None self._runtime = None @property def shader(self): return self._shader def load(self, name): props = self._loader.load(name, 'props.txt') args = [] if props is not None: args = parse_args(props) in_img = StructArg('input_image', ImagePRGBA(1, 1)) out_img = StructArg('output_image', ImagePRGBA(1, 1)) args.extend([in_img, out_img]) code = self._loader.load(name, 'code.py') self._shader = Shader(code=code, args=args) self._shader.compile() self._runtime = Runtime() self._shader.prepare([self._runtime]) def tmo(self, in_img, out_img): """ Perform tone mapping on input image Args: in_img: Input image out_img: Output image """ if self._shader is None: raise ValueError("Shader is not loaded.") if not isinstance(in_img, ImagePRGBA) and not isinstance( out_img, ImagePRGBA): raise ValueError("ImagePRGBA is expected insted of", in_img, out_img) w1, h1 = in_img.size() w2, h2 = out_img.size() if w1 != w2 or h1 != h2: raise ValueError("Input and output image must be same size!") self._shader.set_value('input_image', in_img) self._shader.set_value('output_image', out_img) self._shader.execute()
def test_linear(self): sphere = Sphere(Vector3(0.0, 0.0, 0.0), 2.0, 0) mgr = ShapeManager() mgr.add('sph1', sphere) sphere2 = Sphere(Vector3(0.0, 2.0, 0.0), 3.0, 0) mgr.add('sph2', sphere2) isector = LinearIsect(mgr) runtimes = [Runtime()] direction = Vector3(-1.0, -1.0, -1.0) direction.normalize() ray = Ray(Vector3(5.0, 5.0, 5.0), direction) isector.compile() isector.prepare(runtimes) code = """ min_dist = 99999.0 p1 = isect_scene(ray, hitpoint, min_dist) """ direction = Vector3(-1.0, -1.0, -1.0) direction.normalize() ray = Ray(Vector3(5.0, 5.0, 5.0), direction) hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0) r_arg = StructArg('ray', ray) harg = StructArg('hitpoint', hitpoint) p1 = IntArg('p1', 6) args = [r_arg, harg, p1] shader = Shader(code=code, args=args) shader.compile([isector.shader]) shader.prepare(runtimes) hp2 = isector.isect(ray) shader.execute() hitpoint = shader.get_value('hitpoint') self.assertAlmostEqual(hp2.t, hitpoint.t, places=5) self.assertEqual(hp2.mat_idx, hitpoint.mat_idx) n1 = hp2.normal n2 = hitpoint.normal self.assertAlmostEqual(n1.x, n2.x) self.assertAlmostEqual(n1.y, n2.y, places=6) self.assertAlmostEqual(n1.z, n2.z) self.assertAlmostEqual(hitpoint.hit.x, hp2.hit.x, places=6) self.assertAlmostEqual(hitpoint.hit.y, hp2.hit.y, places=6) self.assertAlmostEqual(hitpoint.hit.z, hp2.hit.z, places=6) result = shader.get_value('p1') self.assertEqual(result, 1)
class Tmo: def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'shaders') self._loader = Loader([path]) self._shader = None self._runtime = None @property def shader(self): return self._shader def load(self, name): props = self._loader.load(name, 'props.txt') args = [] if props is not None: args = parse_args(props) in_img = StructArg('input_image', ImagePRGBA(1, 1)) out_img = StructArg('output_image', ImagePRGBA(1, 1)) args.extend([in_img, out_img]) code = self._loader.load(name, 'code.py') self._shader = Shader(code=code, args=args) self._shader.compile() self._runtime = Runtime() self._shader.prepare([self._runtime]) def tmo(self, in_img, out_img): """ Perform tone mapping on input image Args: in_img: Input image out_img: Output image """ if self._shader is None: raise ValueError("Shader is not loaded.") if not isinstance(in_img, ImagePRGBA) and not isinstance(out_img, ImagePRGBA): raise ValueError("ImagePRGBA is expected insted of", in_img, out_img) w1, h1 = in_img.size() w2, h2 = out_img.size() if w1 != w2 or h1 != h2: raise ValueError("Input and output image must be same size!") self._shader.set_value('input_image', in_img) self._shader.set_value('output_image', out_img) self._shader.execute()
def test_isect_rect(self): rect_shader = Rectangle.isect_shader('isect_rectangle') rect_shader.compile() runtimes = [Runtime()] rect_shader.prepare(runtimes) code = """ min_dist = 99999.0 p1 = isect_rectangle(ray, rectangle, hitpoint, min_dist) """ origin = Vector3(3.0, 2.5, 0.0) direction = Vector3(0.0, 0.1, 0.88) direction.normalize() ray = Ray(origin, direction) point = Vector3(0.0, 0.0, 55.92) e1 = Vector3(55.28, 0.0, 0.0) e2 = Vector3(0.0, 54.88, 0.0) normal = Vector3(0.0, 0.0, -1.0) rectangle = Rectangle(point, e1, e2, normal) hitpoint = HitPoint.factory() hitpoint.mat_idx = 5 r_arg = StructArg('ray', ray) sph_arg = StructArg('rectangle', rectangle) harg = StructArg('hitpoint', hitpoint) p1 = IntArg('p1', 6) args = [r_arg, sph_arg, harg, p1] shader = Shader(code=code, args=args) shader.compile([rect_shader.shader]) shader.prepare(runtimes) shader.execute() hp2 = rectangle.isect(ray) hitpoint = shader.get_value('hitpoint') self.assertAlmostEqual(hp2.t, hitpoint.t, places=5) self.assertEqual(hp2.mat_idx, hitpoint.mat_idx) n1 = hp2.normal n2 = hitpoint.normal self.assertAlmostEqual(n1.x, n2.x) self.assertAlmostEqual(n1.y, n2.y) self.assertAlmostEqual(n1.z, n2.z) self.assertAlmostEqual(hitpoint.hit.x, hp2.hit.x, places=5) self.assertAlmostEqual(hitpoint.hit.y, hp2.hit.y, places=5) self.assertAlmostEqual(hitpoint.hit.z, hp2.hit.z, places=5) result = shader.get_value('p1') self.assertEqual(result, 1)
def prepare_standalone(self): runtimes = [Runtime()] self.compile() self.prepare(runtimes) code = """ ret = generate_sample(sample) """ args = [StructArg('sample', Sample.factory()), IntArg('ret', 11)] self._standalone = Shader(code=code, args=args) self._standalone.compile([self.shader]) self._standalone.prepare(runtimes)
def test_sampled_point_light(self): sam_mgr = SampledManager() register_sampled_shadepoint(sam_mgr) runtimes = [Runtime()] lgt = GeneralLight() lgt.load('point', sam_mgr, spectral=True) lgt.set_value('intensity', RGBSpectrum(0.3, 0.3, 0.3)) lgt.set_value('position', Vector3(2.0, 2.0, 2.0)) lgt.compile() lgt.prepare(runtimes) ptrs = lgt.shader.get_ptrs() ptr_func = PointerArg('ptr_func', ptrs[0]) spec = SampledArg('spec', sam_mgr.zero()) wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0)) pos = Vec3Arg('position', Vector3(0.0, 0.0, 0.0)) code = """ hp = HitPoint() hp.hit = (4.0, 5, 6) sp = ShadePoint() __light_radiance(hp, sp, ptr_func) spec = sp.light_intensity wi = sp.wi position = sp.light_position """ shader = Shader(code=code, args=[ptr_func, wi, spec, pos]) shader.compile() shader.prepare(runtimes) shader.execute() wi = Vector3(2.0, 2.0, 2.0) - Vector3(4.0, 5.0, 6.0) wi.normalize() wi_s = shader.get_value('wi') self.assertAlmostEqual(wi.x, wi_s.x) self.assertAlmostEqual(wi.y, wi_s.y) self.assertAlmostEqual(wi.z, wi_s.z) p = Vector3(2.0, 2.0, 2.0) p_s = shader.get_value('position') self.assertAlmostEqual(p.x, p_s.x) self.assertAlmostEqual(p.y, p_s.y) self.assertAlmostEqual(p.z, p_s.z) s = sam_mgr.rgb_to_sampled(RGBSpectrum(0.3, 0.3, 0.3), illum=True) s_s = shader.get_value('spec') for i in range(len(s.samples)): self.assertAlmostEqual(s.samples[i], s_s.samples[i])
def _lgt_radiance(self, color_mgr): code = """ ptr_func = lgt_ptrs[mat_idx] __light_radiance(hitpoint, shadepoint, ptr_func) """ lgt_ptrs = ArrayArg('lgt_ptrs', PtrsArray()) al = ArgList('lgt_ptrs', [lgt_ptrs]) func_args = self._func_args(color_mgr.zero()) args = [al] self.rad_shader = Shader(code=code, args=args, name='light_radiance', func_args=func_args, is_func=True)
class SamplerGenerator(): def __init__(self, sampler): self.sampler = sampler self.prepare_standalone() def prepare_standalone(self): self.sampler.create_shader() runtimes = [Runtime()] self.sampler.compile() self.sampler.prepare(runtimes) code = """ ret = generate_sample(sample) """ args = [StructArg('sample', Sample.factory()), IntArg('ret', 11)] self._standalone = Shader(code=code, args=args) self._standalone.compile([self.sampler.shader]) self._standalone.prepare(runtimes) def generate_sample(self): self._standalone.execute() ret = self._standalone.get_value('ret') if ret == 0: return False sample = self._standalone.get_value('sample') return sample
def _mtl_pdf(self, color_mgr): code = """ ptr_func = mtl_pdf_ptrs[mat_idx] __material_pdf(hitpoint, shadepoint, ptr_func) """ pdf_ptrs = ArrayArg('mtl_pdf_ptrs', PtrsArray()) al = ArgList('mtl_pdf_ptrs', [pdf_ptrs]) func_args = self._func_args(color_mgr.zero()) args = [al] self.pdf_shader = Shader(code=code, args=args, name='material_pdf', func_args=func_args, is_func=True)
def load(self, name): props = self._loader.load(name, 'props.txt') args = [] if props is not None: args = parse_args(props) in_img = StructArg('input_image', ImagePRGBA(1, 1)) out_img = StructArg('output_image', ImagePRGBA(1, 1)) args.extend([in_img, out_img]) code = self._loader.load(name, 'code.py') self._shader = Shader(code=code, args=args) self._shader.compile() self._runtime = Runtime() self._shader.prepare([self._runtime])
def light_sample(self, spectrum): area = self.edge_a.length() * self.edge_b.length() inv_area = 1.0 / area code = """ rnd = random2() shadepoint.light_pdf = inv_area shadepoint.light_normal = normal shadepoint.light_position = point + edge_a * rnd[0] + edge_b * rnd[1] """ inv_area = FloatArg('inv_area', inv_area) normal = Vec3Arg('normal', self.normal) point = Vec3Arg('point', self.point) eda = Vec3Arg('edge_a', self.edge_a) edb = Vec3Arg('edge_b', self.edge_b) args = [inv_area, normal, point, eda, edb] func_args = [ StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum)) ] name = 'rect_sample_%i' % id(self) return Shader(code=code, args=args, name=name, func_args=func_args, is_func=True)
def light_sample(self, spectrum): area = (self.p1 - self.p0).cross(self.p2 - self.p0).length() * 0.5 inv_area = 1.0 / area code = """ r1 = random() tmp = 1.0 - r1 tmp = sqrt(tmp) beta = 1.0 - tmp gamma = tmp * random() shadepoint.light_position = (1.0 - beta - gamma) * p0 + beta * p1 + gamma * p2 shadepoint.light_pdf = inv_area shadepoint.light_normal = normal """ inv_area = FloatArg('inv_area', inv_area) normal = Vec3Arg('normal', self.normal) p0 = Vec3Arg('p0', self.p0) p1 = Vec3Arg('p1', self.p1) p2 = Vec3Arg('p2', self.p2) args = [inv_area, normal, p0, p1, p2] func_args = [StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum))] name = 'triangle_sample_%i' % id(self) return Shader(code=code, args=args, name=name, func_args=func_args, is_func=True)
def create_shader(self): code = """ if cury == endy: return 0 rnds = random2() n = float(nsamples) n = sqrt(n) px = (subx + rnds[0]) / n py = (suby + rnds[1]) / n tmp = curx - width * 0.5 + px tmp2 = cury - height * 0.5 + py sample.x = pixelsize * tmp sample.y = pixelsize * tmp2 sample.px = px sample.py = py sample.ix = curx sample.iy = cury sample.weight = 1.0 curx = curx + 1 if curx == endx: curx = tile.x cury = cury + 1 return 1 """ args = self.args() func_args = [StructArgPtr('sample', Sample.factory())] self.shader = Shader(code=code, args=args, name='generate_sample', func_args=func_args, is_func=True) return self.shader
def create_shader(self): code = """ if cury == endy: return 0 tmp = curx - width * 0.5 + 0.5 tmp2 = cury - height * 0.5 + 0.5 sample.x = pixelsize * tmp sample.y = pixelsize * tmp2 sample.px = 0.5 sample.py = 0.5 sample.ix = curx sample.iy = cury sample.weight = 1.0 curx = curx + 1 if curx == endx: curx = tile.x cury = cury + 1 return 1 """ args = self.args() func_args = [StructArgPtr('sample', Sample.factory())] self.shader = Shader(code=code, args=args, name='generate_sample', func_args=func_args, is_func=True) return self.shader
def _sampled_to_rgb_shader(sampled_mgr): code = """ x = cie_x * spec y = cie_y * spec z = cie_z * spec X = sum_samples(x) * scale Y = sum_samples(y) * scale Z = sum_samples(z) * scale r = 3.240479 * X - 1.537150 * Y - 0.498535 * Z g = -0.969256 * X + 1.875991 * Y + 0.041556 * Z b = 0.055648 * X - 0.204043 * Y + 1.057311 * Z return float3(r, g, b) """ spec = sampled_mgr.zero() spec_arg = SampledArgPtr('spec', 0, spec) scale = (sampled_mgr.end - sampled_mgr.start) / (sampled_mgr.yint * sampled_mgr.nsamples) p1 = FloatArg('scale', scale) cie_x = SampledArg('cie_x', sampled_mgr._cie_x) cie_y = SampledArg('cie_y', sampled_mgr._cie_y) cie_z = SampledArg('cie_z', sampled_mgr._cie_z) shader = Shader(code=code, args=[p1, cie_x, cie_y, cie_z], name='spectrum_to_rgb', func_args=[spec_arg], is_func=True) return shader
def _rgb_luminance_shader(rgb_mgr): code = """ return rgb[0] * 0.212671 + rgb[1] * 0.715160 + rgb[2] * 0.072169 """ rgb = RGBArg('rgb', RGBSpectrum(0.0, 0.0, 0.0)) shader = Shader(code=code, name='luminance', func_args=[rgb], is_func=True) return shader
def load(self, shader_name): args = [] text = self._loader.load(shader_name, 'props.txt') if text is not None: args = parse_args(text) args.append(FloatArg('xwidth', self.xwidth)) args.append(FloatArg('ywidth', self.ywidth)) code = self._loader.load(shader_name, 'code.py') if code is None: raise ValueError("code.py in %s shader dont exist!" % shader_name) func_args = [StructArgPtr('sample', Sample.factory())] self.shader = Shader(code=code, args=args, name='filter_sample', func_args=func_args, is_func=True)
def compile_shaders(self, color_mgr, shaders=[]): for l in self._lights: l.compile(shaders) self._lgt_radiance(color_mgr) self.rad_shader.compile(shaders, color_mgr=color_mgr) self._lgt_emission(color_mgr) self.emission_shader.compile(shaders, color_mgr=color_mgr) code = "return %i\n" % len(self._lights) self.nlights_shader = Shader(code=code, name='number_of_lights', is_func=True) self.nlights_shader.compile() self._compile_environment(color_mgr, shaders)
def test_isect_sph(self): sph_shader = Sphere.isect_shader('isect_sphere') sph_shader.compile() runtimes = [Runtime()] sph_shader.prepare(runtimes) code = """ min_dist = 99999.0 p1 = isect_sphere(ray, sphere, hitpoint, min_dist) """ direction = Vector3(-1.0, -1.0, -1.0) direction.normalize() ray = Ray(Vector3(5.0, 5.0, 5.0), direction) sphere = Sphere(Vector3(0.0, 0.0, 0.0), 2.0, 0) hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0) r_arg = StructArg('ray', ray) sph_arg = StructArg('sphere', sphere) harg = StructArg('hitpoint', hitpoint) p1 = IntArg('p1', 6) args = [r_arg, sph_arg, harg, p1] shader = Shader(code=code, args=args) shader.compile([sph_shader.shader]) shader.prepare(runtimes) shader.execute() hp2 = sphere.isect(ray) hitpoint = shader.get_value('hitpoint') self.assertAlmostEqual(hp2.t, hitpoint.t) self.assertEqual(hp2.mat_idx, hitpoint.mat_idx) n1 = hp2.normal n2 = hitpoint.normal self.assertAlmostEqual(n1.x, n2.x) self.assertAlmostEqual(n1.y, n2.y) self.assertAlmostEqual(n1.z, n2.z) self.assertAlmostEqual(hitpoint.hit.x, hp2.hit.x) self.assertAlmostEqual(hitpoint.hit.y, hp2.hit.y) self.assertAlmostEqual(hitpoint.hit.z, hp2.hit.z) result = shader.get_value('p1') self.assertEqual(result, 1)
def test_isect_flat_triangle1(self): runtimes = [Runtime()] tri_shader = FlatTriangle.isect_shader('isect_flat_triangle') tri_shader.compile() tri_shader.prepare(runtimes) p0 = Vector3(-0.0831229984, 0.0591476, -0.03213749) p1 = Vector3(-0.082775, 0.059025, -0.031787) p2 = Vector3(-0.0831229, 0.0591773, -0.031787) origin = Vector3(-0.21276909825205803, -0.021492251798510553, -0.09822520208358765) direction = Vector3(0.7788769269741005, 0.4843782624535974, 0.3984073687694737) ray = Ray(origin, direction) hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0) t = FlatTriangle(p0, p1, p2) code = """ min_dist = 150.0 ret = isect_flat_triangle(ray, triangle, hitpoint, min_dist) """ r_arg = StructArg('ray', ray) tri_arg = StructArg('triangle', t) harg = StructArg('hitpoint', hitpoint) ret = IntArg('ret', 6) args = [r_arg, tri_arg, harg, ret] shader = Shader(code=code, args=args) shader.compile([tri_shader.shader]) shader.prepare(runtimes) shader.execute() min_dist = 150.0 hit = t.isect(ray, min_dist) hp = shader.get_value('hitpoint') self.assertAlmostEqual(hit.t, hp.t, places=6) self._almost_equal_vec3(hit.hit, hp.hit, places=6) self._almost_equal_vec3(hit.normal, hp.normal, places=6) self.assertEqual(hit.mat_idx, hp.mat_idx) self.assertAlmostEqual(hit.u, hp.u) self.assertAlmostEqual(hit.v, hp.v)
class EnvironmentLight(Light): def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'env_shaders') self._loader = Loader([path]) def _func_args(self, spectrum): func_args = [ StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum)) ] return func_args def load(self, shader_name, color_mgr): self._color_mgr = color_mgr self._shader_name = shader_name args = [] text = self._loader.load(shader_name, 'props.txt') if text is not None: args = parse_args(text, color_mgr) code = self._loader.load(shader_name, 'env.py') if code is None: raise ValueError("env.py in %s shader dont exist!" % shader_name) name = 'env_light_%i' % id(args) func_args = self._func_args(color_mgr.zero()) self.env_shader = Shader(code=code, args=args, name='environment_emission', func_args=func_args, is_func=True) def get_value(self, name): if self.env_shader is None: raise ValueError("Environment shader is not loaded!") return self.env_shader.get_value(name) def set_value(self, name, val): if self.env_shader is None: raise ValueError("Environment shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val, illum=True) self.env_shader.set_value(name, val)
def load(self, shader_name, color_mgr): self._color_mgr = color_mgr self._shader_name = shader_name args = self._load_args() ptr_lgt_sample = PointerArg('ptr_light_sample', 0) lgt_sample = ArgList('ptr_light_sample', [ptr_lgt_sample]) args.append(lgt_sample) ptr_mat_emission = PointerArg('ptr_mat_emission', 0) mat_emission = ArgList('ptr_mat_emission', [ptr_mat_emission]) args.append(mat_emission) code = self._loader.load(shader_name, 'code.py') if code is None: raise ValueError("code.py in %s shader dont exist!" % shader_name) name = 'light_%i' % id(args) func_args = self._func_args(color_mgr.zero()) self.shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True) # area light emission shader name = 'light_emission%i' % id(args) func_args = self._func_args(color_mgr.zero()) args = [] ptr_lgt_pdf = PointerArg('ptr_light_pdf', 0) lgt_pdf = ArgList('ptr_light_pdf', [ptr_lgt_pdf]) args.append(lgt_pdf) ptr_mat_emission = PointerArg('ptr_mat_emission', 0) mat_emission = ArgList('ptr_mat_emission', [ptr_mat_emission]) args.append(mat_emission) code = """ __light_pdf(hitpoint, shadepoint, ptr_light_pdf) __material_emission(hitpoint, shadepoint, ptr_mat_emission) """ self.emission_shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True)
def isect_shader(cls, shader_name): code = """ temp = ray.origin - sphere.origin r_dir = ray.direction a = dot(r_dir, r_dir) b = dot(temp, r_dir) * 2.0 c = dot(temp, temp) - sphere.radius * sphere.radius disc = b * b - 4.0 * a * c if disc < 0.0: return 0 e = sqrt(disc) denom = 2.0 * a t = (-1.0 * b - e) / denom if t > 0.0005: if t < min_dist: normal = (temp + r_dir * t) * (1.0 / sphere.radius) hit = ray.origin + r_dir * t hitpoint.t = t hitpoint.normal = normal hitpoint.hit = hit hitpoint.mat_idx = sphere.mat_idx hitpoint.light_id = sphere.light_id hitpoint.u = 0.0 hitpoint.v = 0.0 return 1 t = (-1.0 * b + e) / denom if t > 0.0005: if t < min_dist: normal = (temp + r_dir * t) * (1.0 / sphere.radius) hit = ray.origin + r_dir * t hitpoint.t = t hitpoint.normal = normal hitpoint.hit = hit hitpoint.mat_idx = sphere.mat_idx hitpoint.light_id = sphere.light_id hitpoint.u = 0.0 hitpoint.v = 0.0 return 1 return 0 """ func_args = [ StructArgPtr('ray', Ray.factory()), StructArgPtr('sphere', Sphere.factory()), StructArgPtr('hitpoint', HitPoint.factory()), FloatArg('min_dist', 0.0) ] shader = Shader(code=code, args=[], name=shader_name, func_args=func_args, is_func=True) return DependencyShader(shader)
def load(self, shader_name, color_mgr, image_factory=None): self._color_mgr = color_mgr self._shader_name = shader_name self._image_factory = image_factory code = self._loader.load(shader_name, 'bsdf.py') if code is None: raise ValueError("bsdf.py in %s doesnt exist!" % shader_name) args = self._load_args() name = 'material_%i' % id(args) s = color_mgr.zero() func_args = self._func_args(s) self._bsdf_shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True) #Sampling shader code = self._loader.load(self._shader_name, 'sample.py') if code is None: code = self._default_sampling() args = self._load_args() ptr_mat_bsdf = PointerArg('ptr_mat_bsdf', 0) ptr_mat_pdf = PointerArg('ptr_mat_pdf', 0) ptr_bsdf = ArgList('ptr_mat_bsdf', [ptr_mat_bsdf]) ptr_pdf = ArgList('ptr_mat_pdf', [ptr_mat_pdf]) args.append(ptr_bsdf) args.append(ptr_pdf) name = 'material_sampling_%i' % id(args) func_args = self._func_args(s) self._sampling_shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True) #material pdf code = self._loader.load(self._shader_name, 'pdf.py') if code is None: code = self._default_pdf() args = self._load_args() name = 'material_pdf_%i' % id(args) func_args = self._func_args(s) self._pdf_shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True)
def test_light_manager(self): sam_mgr = SampledManager() register_rgb_shadepoint() runtimes = [Runtime(), Runtime()] lgt = GeneralLight() lgt.load('point', sam_mgr, spectral=False) lgt2 = GeneralLight() lgt2.load('point', sam_mgr, spectral=False) lgt2.set_value('intensity', RGBSpectrum(0.3, 0.3, 0.3)) lgt2.set_value('position', Vector3(2.0, 2.0, 2.0)) mgr = LightManager() mgr.add('light1', lgt) mgr.add('light2', lgt2) mgr.compile_shaders(sam_mgr, spectral=False) mgr.prepare_shaders(runtimes) code = """ hp = HitPoint() hp.hit = (4.0, 5, 6) sp = ShadePoint() light_radiance(hp, sp, 1) wi = sp.wi n = number_of_lights() """ wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0)) nlights = IntArg('n', 999) shader = Shader(code=code, args=[wi, nlights]) shader.compile(shaders=[mgr.rad_shader, mgr.nlights_shader]) shader.prepare(runtimes) shader.execute() wi = Vector3(2.0, 2.0, 2.0) - Vector3(4.0, 5.0, 6.0) wi.normalize() wi_s = shader.get_value('wi') self.assertAlmostEqual(wi.x, wi_s.x) self.assertAlmostEqual(wi.y, wi_s.y) self.assertAlmostEqual(wi.z, wi_s.z) self.assertEqual(2, shader.get_value('n'))
def _rgb_to_rgb_shader(rgb_mgr): code = """ return float3(rgb[0], rgb[1], rgb[2]) """ rgb = RGBArg('rgb', RGBSpectrum(0.0, 0.0, 0.0)) shader = Shader(code=code, name='spectrum_to_rgb', func_args=[rgb], is_func=True) return shader
def test_material_sampling_manager(self): sam_mgr = SampledManager() register_rgb_shadepoint() runtimes = [Runtime(), Runtime()] mat = Material() mat.load('lambertian', sam_mgr, spectral=False) mat.set_value('diffuse', RGBSpectrum(0.2, 0.3, 0.4)) mgr = MaterialManager() mgr.add('material1', mat) mgr.compile_shaders(sam_mgr, spectral=False) mgr.prepare_shaders(runtimes) code = """ hp = HitPoint() hp.normal = (0.1, 0.4, 0.66) hp.normal = normalize(hp.normal) sp = ShadePoint() material_sampling(hp, sp, 0) pdf = sp.pdf wi = sp.wi spec = sp.material_reflectance """ pdf = FloatArg('pdf', 0.0) wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0)) spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5)) shader = Shader(code=code, args=[pdf, wi, spec]) shader.compile(shaders=[mgr.sampling_shader]) shader.prepare(runtimes) shader.execute() s = shader.get_value('pdf') print(s) s = shader.get_value('wi') print(s) s = shader.get_value('spec') print(s) normal = Vector3(0.1, 0.4, 0.66) normal.normalize() print(cos_hemisphere(r1=0.1, r2=0.06, normal=normal,e=1.0))
class EnvironmentLight(Light): def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'env_shaders') self._loader = Loader([path]) def _func_args(self, spectrum): func_args = [StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum))] return func_args def load(self, shader_name, color_mgr): self._color_mgr = color_mgr self._shader_name = shader_name args = [] text = self._loader.load(shader_name, 'props.txt') if text is not None: args = parse_args(text, color_mgr) code = self._loader.load(shader_name, 'env.py') if code is None: raise ValueError("env.py in %s shader dont exist!" % shader_name) name = 'env_light_%i' % id(args) func_args = self._func_args(color_mgr.zero()) self.env_shader = Shader(code=code, args=args, name='environment_emission', func_args=func_args, is_func=True) def get_value(self, name): if self.env_shader is None: raise ValueError("Environment shader is not loaded!") return self.env_shader.get_value(name) def set_value(self, name, val): if self.env_shader is None: raise ValueError("Environment shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val, illum=True) self.env_shader.set_value(name, val)
def test_isect_flat_triangle(self): runtimes = [Runtime()] tri_shader = FlatTriangle.isect_shader('isect_flat_triangle') tri_shader.compile() tri_shader.prepare(runtimes) p0 = Vector3(2.2, 4.4, 6.6) p1 = Vector3(1.1, 1.1, 1.1) p2 = Vector3(5.1, -1.1, 5.1) origin = Vector3(0.0, 0.0, 0.0) direction = Vector3(3, 3.0, 3.01) direction.normalize() ray = Ray(origin, direction) hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0) t = FlatTriangle(p0, p1, p2) code = """ min_dist = 150.0 ret = isect_flat_triangle(ray, triangle, hitpoint, min_dist) """ r_arg = StructArg('ray', ray) tri_arg = StructArg('triangle', t) harg = StructArg('hitpoint', hitpoint) ret = IntArg('ret', 6) args = [r_arg, tri_arg, harg, ret] shader = Shader(code=code, args=args) shader.compile([tri_shader.shader]) shader.prepare(runtimes) shader.execute() min_dist = 150.0 hit = t.isect(ray, min_dist) hp = shader.get_value('hitpoint') self.assertAlmostEqual(hit.t, hp.t, places=6) self._almost_equal_vec3(hit.hit, hp.hit, places=6) self._almost_equal_vec3(hit.normal, hp.normal, places=6) self.assertEqual(hit.mat_idx, hp.mat_idx) self.assertAlmostEqual(hit.u, hp.u) self.assertAlmostEqual(hit.v, hp.v)
def test_isect_flat_triangle1(self): runtimes = [Runtime()] tri_shader = FlatTriangle.isect_shader('isect_flat_triangle') tri_shader.compile() tri_shader.prepare(runtimes) p0 = Vector3(-0.0831229984, 0.0591476, -0.03213749) p1 = Vector3(-0.082775, 0.059025, -0.031787) p2 = Vector3(-0.0831229, 0.0591773, -0.031787) origin = Vector3(-0.21276909825205803,-0.021492251798510553,-0.09822520208358765) direction = Vector3(0.7788769269741005,0.4843782624535974,0.3984073687694737) ray = Ray(origin, direction) hitpoint = HitPoint(0.0, Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), 6, 0.0, 0.0) t = FlatTriangle(p0, p1, p2) code = """ min_dist = 150.0 ret = isect_flat_triangle(ray, triangle, hitpoint, min_dist) """ r_arg = StructArg('ray', ray) tri_arg = StructArg('triangle', t) harg = StructArg('hitpoint', hitpoint) ret = IntArg('ret', 6) args = [r_arg, tri_arg, harg, ret] shader = Shader(code=code, args=args) shader.compile([tri_shader.shader]) shader.prepare(runtimes) shader.execute() min_dist = 150.0 hit = t.isect(ray, min_dist) hp = shader.get_value('hitpoint') self.assertAlmostEqual(hit.t, hp.t, places=6) self._almost_equal_vec3(hit.hit, hp.hit, places=6) self._almost_equal_vec3(hit.normal, hp.normal, places=6) self.assertEqual(hit.mat_idx, hp.mat_idx) self.assertAlmostEqual(hit.u, hp.u) self.assertAlmostEqual(hit.v, hp.v)
def load(self, shader_name, color_mgr): args = [] text = self._loader.load(shader_name, 'props.txt') if text is not None: args = parse_args(text, color_mgr) code = self._loader.load(shader_name, 'code.py') if code is None: raise ValueError("code.py in %s shader dont exist!" % shader_name) name = 'light_%i' % id(args) func_args = self._func_args(color_mgr.zero()) self.shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True) self._color_mgr = color_mgr self._shader_name = shader_name
def test_isect_b_flat_triangle(self): runtimes = [Runtime()] tri_shader = FlatTriangle.isect_b_shader('isect_b_flat_triangle') tri_shader.compile() tri_shader.prepare(runtimes) p0 = Vector3(2.2, 4.4, 6.6) p1 = Vector3(1.1, 1.1, 1.1) p2 = Vector3(5.1, -1.1, 5.1) origin = Vector3(0.0, 0.0, 0.0) direction = Vector3(3, 3.0, 3.01) direction.normalize() ray = Ray(origin, direction) t = FlatTriangle(p0, p1, p2) code = """ min_dist = 150.0 ret = isect_b_flat_triangle(ray, triangle, min_dist) """ r_arg = StructArg('ray', ray) tri_arg = StructArg('triangle', t) ret = IntArg('ret', 6) args = [r_arg, tri_arg, ret] shader = Shader(code=code, args=args) shader.compile([tri_shader.shader]) shader.prepare(runtimes) shader.execute() min_dist = 150.0 hit = t.isect_b(ray, min_dist) hit2 = shader.get_value('ret') if hit2 == 0: hit2 = False elif hit2 == 1: hit2 = True else: raise ValueError("Unexpected value for isect flat triangle ", hit2) self.assertEqual(hit, hit2)
def _compile_environment(self, color_mgr, shaders=[]): if self._env_light is not None: self.env_shader = self._env_light.env_shader self.env_shader.compile(shaders, color_mgr=color_mgr) return # We create dummy shader for environment emission code = ''' shadepoint.light_intensity = Spectrum(0.0) shadepoint.light_pdf = 1.0 ''' spec = color_mgr.zero() func_args = [StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spec))] self.env_shader = Shader(code=code, name='environment_emission', func_args=func_args, is_func=True) self.env_shader.compile(shaders, color_mgr=color_mgr)
def _lgt_emission(self, color_mgr): code = """ if light_id < 0: shadepoint.light_intensity = Spectrum(0.0) shadepoint.light_pdf = 1.0 else: ptr_func = lgt_ptrs[light_id] __light_emission(hitpoint, shadepoint, ptr_func) """ lgt_ptrs = ArrayArg('lgt_ptrs', PtrsArray()) al = ArgList('lgt_ptrs', [lgt_ptrs]) spec = color_mgr.zero() func_args = [StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spec)), IntArg('light_id', -1)] args = [al] self.emission_shader = Shader(code=code, args=args, name='light_emission', func_args=func_args, is_func=True)
class Integrator: def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'int_shaders') self._loader = Loader([path]) def load(self, shader_name, color_mgr): text = self._loader.load(shader_name, 'props.txt') args = [] if text is not None: args = parse_args(text) code = self._loader.load(shader_name, 'code.py') if code is None: raise ValueError("Integrator %s code is missing!" % shader_name) #array of shadepoints for debuging purpose sp = ShadePoint.factory(color_mgr.zero()) arr = ObjArray(sp) for i in range(10): arr.append(sp) arg = ArrayArg('path_array', arr) args.append(arg) hdr_buffer = StructArg('hdr_buffer', ImagePRGBA(1, 1)) args.append(hdr_buffer) self.shader = Shader(code=code, args=args) self._color_mgr = color_mgr def compile(self, shaders=[]): self.shader.compile(shaders, color_mgr=self._color_mgr) def prepare(self, runtimes): self.shader.prepare(runtimes) def execute(self, hdr_buffer): self.shader.set_value('hdr_buffer', hdr_buffer) self.shader.execute()