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 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)
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 test_mesh(mesh, nrays=1): dep_shader = type(mesh).isect_shader('ray_flat_mesh_isect') dep_shader.compile() runtimes = [Runtime()] dep_shader.prepare(runtimes) code = """ min_dist = 99999.0 ret = ray_flat_mesh_isect(ray, mesh, hitpoint, min_dist) """ ray = generate_ray(mesh) 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) mesh_arg = StructArg('mesh', mesh) harg = StructArg('hitpoint', hitpoint) ret = IntArg('ret', 6) args = [r_arg, mesh_arg, harg, ret] shader = Shader(code=code, args=args) shader.compile([dep_shader.shader]) shader.prepare(runtimes) for i in range(nrays): ray = generate_ray(mesh) # origin = Vector3(-0.21099534597992897,-0.02090535280108452,-0.09716709856688976) # direction = Vector3(0.7856996643888073,0.4629769683728137,0.4102783983292736) # ray = Ray(origin, direction) shader.set_value('ray', ray) hp2 = mesh.isect(ray) hp, index = isect_ray_mesh(ray, mesh) shader.execute() # print(hp, shader.get_value('ret')) if hp: ret = shader.get_value('ret') hp_new = shader.get_value('hitpoint') if round(hp.t - hp_new.t, 5) != 0: print(hp.t, hp_new.t, ret, index, hp2.t) print(ray.origin) print(ray.direction) p0, p1, p2 = mesh.get_points(index) print(p0) print(p1) print(p2) print('------------------------------------------')
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 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_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 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_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)
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_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_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 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))
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))
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 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 test_rgb_area_light(self): sam_mgr = SampledManager() register_rgb_shadepoint() 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) material = Material() material.load('lambertian_emiter', sam_mgr) e = RGBSpectrum(0.5, 0.5, 0.5) material.set_value('emission', e) runtimes = [Runtime()] lgt = AreaLight(shape=rectangle, material=material) lgt.load('general', sam_mgr, spectral=False) lgt.compile() lgt.prepare(runtimes) ptrs = lgt.shader.get_ptrs() ptr_func = PointerArg('ptr_func', ptrs[0]) spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5)) wi = Vec3Arg('wi', Vector3(0.0, 0.0, 0.0)) pos = Vec3Arg('position', Vector3(0.0, 0.0, 0.0)) n = Vec3Arg('normal', Vector3(0.0, 0.0, 0.0)) pdf = FloatArg('pdf', 0.0) emission = RGBArg('emission', RGBSpectrum(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 normal = sp.light_normal pdf = sp.light_pdf emission = sp.material_emission """ shader = Shader(code=code, args=[ptr_func, wi, spec, pos, n, pdf, emission]) shader.compile() shader.prepare(runtimes) shader.execute() print("Position ", shader.get_value('position')) print("Normal ", shader.get_value('normal')) print("Light pdf ", shader.get_value('pdf')) print("Emission ", shader.get_value('emission')) print("Wi ", shader.get_value('wi')) print("Intensity ", shader.get_value('spec'))
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)
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)
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_linear_visiblity(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 = """ p1 = (9, 8, 7) p2 = (-2, -5, -3) ret = visibility(p1, p2) """ ret = IntArg('ret', 6) args = [ret] shader = Shader(code=code, args=args) shader.compile([isector.visible_shader]) shader.prepare(runtimes) p1 = Vector3(9.0, 8.0, 7.0) p2 = Vector3(-2.0, -5.0, -3.0) ret = isector.visibility(p1, p2) shader.execute() ret_s = shader.get_value('ret') if ret is True and ret_s == 0: raise ValueError("Linear visiblity is calculated wrong", ret, ret_s) if ret is False and ret_s == 1: raise ValueError("Linear visiblity is calculated wrong", ret, ret_s)
def test_rgb_luminance(self): runtimes = [Runtime()] color_mgr = RGBManager() lum_shader = luminance_shader(color_mgr) lum_shader.compile(color_mgr=color_mgr) lum_shader.prepare(runtimes) code = """ value = luminance(color) """ spec = RGBSpectrum(0.3, 0.5, 0.7) col = RGBArg('color', spec) val = FloatArg('value', 0.0) shader = Shader(code=code, args=[col, val]) shader.compile(shaders=[lum_shader], color_mgr=color_mgr) shader.prepare(runtimes) shader.execute() value = shader.get_value('value') vv = color_mgr.luminance(spec) self.assertAlmostEqual(value, vv)
def test_rgb_to_sampled_spectrum(self): runtimes = [Runtime()] color_mgr = SampledManager() rgb_to_spec = rgb_to_spectrum_shader(color_mgr) rgb_to_spec.compile(color_mgr=color_mgr) rgb_to_spec.prepare(runtimes) code = """ spec = rgb_to_spectrum(color) """ val = Vector3(0.3, 0.5, 0.7) col = Vec3Arg('color', val) spec = SampledArg('spec', color_mgr.zero()) shader = Shader(code=code, args=[col, spec]) shader.compile(shaders=[rgb_to_spec], color_mgr=color_mgr) shader.prepare(runtimes) shader.execute() value = shader.get_value('spec') vv = color_mgr.rgb_to_sampled(RGBSpectrum(val.x, val.y, val.z)) for i in range(len(value.samples)): self.assertAlmostEqual(value.samples[i], vv.samples[i], places=6)
def test_rgb_to_rgb_spectrum(self): runtimes = [Runtime()] color_mgr = RGBManager() rgb_to_spec = rgb_to_spectrum_shader(color_mgr) rgb_to_spec.compile(color_mgr=color_mgr) rgb_to_spec.prepare(runtimes) code = """ spec = rgb_to_spectrum(color) """ val = Vector3(0.3, 0.5, 0.7) col = Vec3Arg('color', val) spec = RGBArg('spec', RGBSpectrum(0.0, 0.0, 0.0)) shader = Shader(code=code, args=[col, spec]) shader.compile(shaders=[rgb_to_spec], color_mgr=color_mgr) shader.prepare(runtimes) shader.execute() value = shader.get_value('spec') self.assertAlmostEqual(value.r, val.x) self.assertAlmostEqual(value.g, val.y) self.assertAlmostEqual(value.b, val.z)
def test_rgb_to_rgb(self): runtimes = [Runtime()] color_mgr = RGBManager() 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) col = RGBArg('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') self.assertAlmostEqual(value.x, 0.3) self.assertAlmostEqual(value.y, 0.5) self.assertAlmostEqual(value.z, 0.4)
class Material: def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'mat_shaders') self._loader = Loader([path]) self._bsdf_shader = None self._sampling_shader = None self._shader_name = None def is_emissive(self): if self._shader_name is None: return False return self._loader.exist(self._shader_name, 'emission.py') def _func_args(self, spectrum): func_args = [ StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum)) ] return func_args def _load_args(self): args = [] text = self._loader.load(self._shader_name, 'props.txt') if text is not None: args = parse_args(text, self._color_mgr, image_factory=self._image_factory) return args 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 _default_sampling(self): code = """ r1 = random() r2 = random() e = 1.0 phi = 2.0 * 3.14159 * r1 exponent = 1.0 / (e + 1.0) cos_theta = pow(r2, exponent) tmp = 1.0 - cos_theta * cos_theta sin_theta = sqrt(tmp) sin_phi = sin(phi) cos_phi = cos(phi) pu = sin_theta * cos_phi pv = sin_theta * sin_phi pw = cos_theta w = hitpoint.normal tv = (0.0034, 1.0, 0.0071) v = cross(tv, w) v = normalize(v) u = cross(v, w) ndir = u * pu + v * pv + w * pw shadepoint.wi = normalize(ndir) __material_pdf(hitpoint, shadepoint, ptr_mat_pdf) __material_reflectance(hitpoint, shadepoint, ptr_mat_bsdf) """ return code def _default_pdf(self): code = """ shadepoint.pdf = dot(hitpoint.normal, shadepoint.wi) * 0.318309886 """ return code def compile(self, shaders=[]): self._bsdf_shader.compile(shaders, color_mgr=self._color_mgr) self._sampling_shader.compile(shaders, color_mgr=self._color_mgr) self._pdf_shader.compile(shaders, color_mgr=self._color_mgr) def prepare(self, runtimes): self._bsdf_shader.prepare(runtimes) self._pdf_shader.prepare(runtimes) ptrs = self._bsdf_shader.get_ptrs() args = [PointerArg('ptr_mat_bsdf', p) for p in ptrs] ptr_bsdf = self._sampling_shader._get_arg('ptr_mat_bsdf') ptr_bsdf.resize(args) ptrs = self._pdf_shader.get_ptrs() args = [PointerArg('ptr_mat_pdf', p) for p in ptrs] ptr_pdf = self._sampling_shader._get_arg('ptr_mat_pdf') ptr_pdf.resize(args) self._sampling_shader.prepare(runtimes) def emission_shader(self, shaders=[]): args = self._load_args() code = self._loader.load(self._shader_name, 'emission.py') if code is None: raise ValueError("emission.py in %s dont exist!" % self._shader_name) name = 'material_emission_%i' % id(args) s = self._color_mgr.zero() func_args = self._func_args(s) emission_shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True) return emission_shader def sync_shader_props(self, shader): for arg in shader.args: val = self.get_value(arg.name) shader.set_value(arg.name, val) def set_value(self, name, val): if self._bsdf_shader is None: raise ValueError("Material shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val) self._bsdf_shader.set_value(name, val) self._sampling_shader.set_value(name, val) self._pdf_shader.set_value(name, val) def get_value(self, name): if self._bsdf_shader is None: raise ValueError("Material shader is not loaded!") return self._bsdf_shader.get_value(name) def output(self, name): txt = 'Material\n' txt += 'type = %s\n' % self._shader_name txt += 'name = %s\n' % name args = self._load_args() for arg in args: value = self.get_value(arg.name) txt += output_arg(arg.name, value) txt += 'End\n' return txt
def atest_material_glass(self): sam_mgr = SampledManager() register_rgb_shadepoint() runtimes = [Runtime()] mat = Material() mat.load('glass', sam_mgr, spectral=False) mat.set_value('ior', 1.5) mgr = MaterialManager() mgr.add('material1', mat) shaders = shaders_functions() for shader in shaders: shader.compile() shader.prepare(runtimes) mgr.compile_shaders(sam_mgr, spectral=False, shaders=shaders) mgr.prepare_shaders(runtimes) code = """ hp = HitPoint() hp.normal = normal sp = ShadePoint() sp.wo = wo 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)) ww = Vector3(5.0, 1.0, 0.0) ww.normalize() wo = Vec3Arg('wo', ww) nn = Vector3(0.0, 1.0, 0.0) nn.normalize() normal = Vec3Arg('normal', nn) spec = RGBArg('spec', RGBSpectrum(0.5, 0.5, 0.5)) shader = Shader(code=code, args=[pdf, wi, wo, normal, spec]) shader.compile(shaders=[mgr.sampling_shader]) shader.prepare(runtimes) shader.execute() s = shader.get_value('wi') print(s) s = shader.get_value('pdf') print(s) s = shader.get_value('spec') print(s) print('------------------------------') print('wo', ww) wi, pdf, ref = sampling_glass(1.5, ww, nn) print("wi", wi) print("pdf", pdf) print("ref", ref) ndotwi = abs(nn.dot(wi)) print("ndotwi", ndotwi) tmp = ndotwi / pdf path_weight = ref * tmp print("path weight", path_weight)
class Material: def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'mat_shaders') self._loader = Loader([path]) self._bsdf_shader = None self._sampling_shader = None self._shader_name = None def is_emissive(self): if self._shader_name is None: return False return self._loader.exist(self._shader_name, 'emission.py') def _func_args(self, spectrum): func_args = [StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum))] return func_args def _load_args(self): args = [] text = self._loader.load(self._shader_name, 'props.txt') if text is not None: args = parse_args(text, self._color_mgr, image_factory=self._image_factory) return args 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 _default_sampling(self): code = """ r1 = random() r2 = random() e = 1.0 phi = 2.0 * 3.14159 * r1 exponent = 1.0 / (e + 1.0) cos_theta = pow(r2, exponent) tmp = 1.0 - cos_theta * cos_theta sin_theta = sqrt(tmp) sin_phi = sin(phi) cos_phi = cos(phi) pu = sin_theta * cos_phi pv = sin_theta * sin_phi pw = cos_theta w = hitpoint.normal tv = (0.0034, 1.0, 0.0071) v = cross(tv, w) v = normalize(v) u = cross(v, w) ndir = u * pu + v * pv + w * pw shadepoint.wi = normalize(ndir) __material_pdf(hitpoint, shadepoint, ptr_mat_pdf) __material_reflectance(hitpoint, shadepoint, ptr_mat_bsdf) """ return code def _default_pdf(self): code = """ shadepoint.pdf = dot(hitpoint.normal, shadepoint.wi) * 0.318309886 """ return code def compile(self, shaders=[]): self._bsdf_shader.compile(shaders, color_mgr=self._color_mgr) self._sampling_shader.compile(shaders, color_mgr=self._color_mgr) self._pdf_shader.compile(shaders, color_mgr=self._color_mgr) def prepare(self, runtimes): self._bsdf_shader.prepare(runtimes) self._pdf_shader.prepare(runtimes) ptrs = self._bsdf_shader.get_ptrs() args = [PointerArg('ptr_mat_bsdf', p) for p in ptrs] ptr_bsdf = self._sampling_shader._get_arg('ptr_mat_bsdf') ptr_bsdf.resize(args) ptrs = self._pdf_shader.get_ptrs() args = [PointerArg('ptr_mat_pdf', p) for p in ptrs] ptr_pdf = self._sampling_shader._get_arg('ptr_mat_pdf') ptr_pdf.resize(args) self._sampling_shader.prepare(runtimes) def emission_shader(self, shaders=[]): args = self._load_args() code = self._loader.load(self._shader_name, 'emission.py') if code is None: raise ValueError("emission.py in %s dont exist!" % self._shader_name) name = 'material_emission_%i' % id(args) s = self._color_mgr.zero() func_args = self._func_args(s) emission_shader = Shader(code=code, args=args, name=name, func_args=func_args, is_func=True) return emission_shader def sync_shader_props(self, shader): for arg in shader.args: val = self.get_value(arg.name) shader.set_value(arg.name, val) def set_value(self, name, val): if self._bsdf_shader is None: raise ValueError("Material shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val) self._bsdf_shader.set_value(name, val) self._sampling_shader.set_value(name, val) self._pdf_shader.set_value(name, val) def get_value(self, name): if self._bsdf_shader is None: raise ValueError("Material shader is not loaded!") return self._bsdf_shader.get_value(name) def output(self, name): txt = 'Material\n' txt += 'type = %s\n' % self._shader_name txt += 'name = %s\n' % name args = self._load_args() for arg in args: value = self.get_value(arg.name) txt += output_arg(arg.name, value) txt += 'End\n' return txt
class GeneralLight(Light): def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'light_shaders') self._loader = Loader([path]) self.shader = None 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): 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 compile(self, shaders=[]): self.shader.compile(shaders, color_mgr=self._color_mgr) def prepare(self, runtimes): self.shader.prepare(runtimes) def get_value(self, name): if self.shader is None: raise ValueError("Light shader is not loaded!") return self.shader.get_value(name) def set_value(self, name, val): if self.shader is None: raise ValueError("Light shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val, illum=True) self.shader.set_value(name, val) def output(self, name): txt = 'Light\n' txt += 'type = %s\n' % self._shader_name txt += 'name = %s\n' % name args = [] text = self._loader.load(self._shader_name, 'props.txt') if text is not None: args = parse_args(text) for arg in args: value = self.get_value(arg.name) txt += output_arg(arg.name, value) txt += 'End\n' return txt
class GeneralLight(Light): def __init__(self): path = os.path.dirname(__file__) path = os.path.join(path, 'light_shaders') self._loader = Loader([path]) self.shader = None 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): 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 compile(self, shaders=[]): self.shader.compile(shaders, color_mgr=self._color_mgr) def prepare(self, runtimes): self.shader.prepare(runtimes) def get_value(self, name): if self.shader is None: raise ValueError("Light shader is not loaded!") return self.shader.get_value(name) def set_value(self, name, val): if self.shader is None: raise ValueError("Light shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val, illum=True) self.shader.set_value(name, val) def output(self, name): txt ='Light\n' txt +='type = %s\n' % self._shader_name txt +='name = %s\n' % name args = [] text = self._loader.load(self._shader_name, 'props.txt') if text is not None: args = parse_args(text) for arg in args: value = self.get_value(arg.name) txt += output_arg(arg.name, value) txt +='End\n' return txt
class AreaLight(Light): def __init__(self, shape, material): path = os.path.dirname(__file__) path = os.path.join(path, 'area_light_shaders') self._loader = Loader([path]) self.shape = shape self.material = material self.shader = None def _func_args(self, spectrum): func_args = [StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum))] return func_args def _load_args(self): args = [] text = self._loader.load(self._shader_name, 'props.txt') if text is not None: args = parse_args(text, self._color_mgr) return args 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 compile(self, shaders=[]): self.shader.compile(shaders, color_mgr=self._color_mgr) self.emission_shader.compile(shaders, color_mgr=self._color_mgr) spec = self._color_mgr.zero() self.light_sample_shader = self.shape.light_sample(spec) self.light_sample_shader.compile(shaders, color_mgr=self._color_mgr) self.light_pdf_shader = self.shape.light_pdf(spec) self.light_pdf_shader.compile(shaders, color_mgr=self._color_mgr) self._emission_shader = self.material.emission_shader() self._emission_shader.compile(shaders, color_mgr=self._color_mgr) def prepare(self, runtimes): self.light_sample_shader.prepare(runtimes) ptrs = self.light_sample_shader.get_ptrs() args = [PointerArg('ptr_light_sample', p) for p in ptrs] lgt_sample = self.shader._get_arg('ptr_light_sample') lgt_sample.resize(args) self.light_pdf_shader.prepare(runtimes) ptrs = self.light_pdf_shader.get_ptrs() args = [PointerArg('ptr_light_pdf', p) for p in ptrs] lgt_pdf = self.emission_shader._get_arg('ptr_light_pdf') lgt_pdf.resize(args) self._emission_shader.prepare(runtimes) self.material.sync_shader_props(self._emission_shader) ptrs = self._emission_shader.get_ptrs() args = [PointerArg('ptr_mat_emission', p) for p in ptrs] ptr_emission = self.shader._get_arg('ptr_mat_emission') ptr_emission.resize(args) args = [PointerArg('ptr_mat_emission', p) for p in ptrs] ptr_emission = self.emission_shader._get_arg('ptr_mat_emission') ptr_emission.resize(args) self.shader.prepare(runtimes) self.emission_shader.prepare(runtimes) def get_value(self, name): if self.shader is None: raise ValueError("Light shader is not loaded!") return self.shader.get_value(name) def set_value(self, name, val): if self.shader is None: raise ValueError("Light shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val, illum=True) self.shader.set_value(name, val)
class Sampler: def __init__(self, width, height, pixelsize=1.0, nthreads=1): self._width = width self._height = height self._pixelsize = pixelsize self._nthreads = nthreads self._pass = 0 self.shader = None @property def nthreads(self): return self._nthreads def get_resolution(self): return (self._width, self._height) def args(self): self._tiles = tiles = create_tiles(self._width, self._height, self._nthreads) n = self.nsamples() subx, suby = self._subpixel_location() args = [IntArg('width', self._width), IntArg('height', self._height), FloatArg('pixelsize', self._pixelsize), IntArg('nsamples', n), IntArg('npass', self._pass), IntArg('subx', subx), IntArg('suby', suby)] targs = [StructArg('tile', tile) for tile in tiles] targ = ArgList('tile', targs) args.append(targ) curx_args = [IntArg('curx', 0) for tile in tiles] curx_arg = ArgList('curx', curx_args) args.append(curx_arg) cury_args = [IntArg('cury', tile.y) for tile in tiles] cury_arg = ArgList('cury', cury_args) args.append(cury_arg) endx_args = [IntArg('endx', tile.width) for tile in tiles] endx_arg = ArgList('endx', endx_args) args.append(endx_arg) endy_args = [IntArg('endy', tile.y + tile.height) for tile in tiles] endy_arg = ArgList('endy', endy_args) args.append(endy_arg) return args def create_shader(self): raise NotImplementedError() def compile(self, shaders=[]): if self.shader is not None: self.shader.compile(shaders) def prepare(self, runtimes): if self._nthreads != len(runtimes): raise ValueError("Expected %i runtimes and got %i!" % (self._nthreads, len(runtimes))) if self.shader is not None: self.shader.prepare(runtimes) def reset(self): self._pass = 0 self._update_shader_values() def _subpixel_location(self): n = self.nsamples() subx = self._pass // int(math.sqrt(n)) suby = self._pass % int(math.sqrt(n)) return (subx, suby) def _update_shader_values(self): if self.shader is not None: self.shader.set_value('npass', self._pass) subx, suby = self._subpixel_location() self.shader.set_value('subx', subx) self.shader.set_value('suby', suby) curx = [0 for tile in self._tiles] self.shader.set_value('curx', curx) cury = [tile.y for tile in self._tiles] self.shader.set_value('cury', cury) def increment_pass(self): self._pass += 1 self._update_shader_values() def has_more_samples(self): if self._pass >= self.nsamples(): return False return True def nsamples(self): return 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 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 output(self): txt = 'Sampler\n' txt += 'type = %s\n' % self.type_name() txt += 'width = %i\n' % self._width txt += 'height = %i\n' % self._height txt += 'nsamples = %i\n' % self.nsamples() txt += 'nthreads = %i\n' % self._nthreads txt += 'pixelsize = %f\n' % self._pixelsize txt += 'End\n' return txt def type_name(self): raise NotImplementedError()
class AreaLight(Light): def __init__(self, shape, material): path = os.path.dirname(__file__) path = os.path.join(path, 'area_light_shaders') self._loader = Loader([path]) self.shape = shape self.material = material self.shader = None def _func_args(self, spectrum): func_args = [ StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum)) ] return func_args def _load_args(self): args = [] text = self._loader.load(self._shader_name, 'props.txt') if text is not None: args = parse_args(text, self._color_mgr) return args 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 compile(self, shaders=[]): self.shader.compile(shaders, color_mgr=self._color_mgr) self.emission_shader.compile(shaders, color_mgr=self._color_mgr) spec = self._color_mgr.zero() self.light_sample_shader = self.shape.light_sample(spec) self.light_sample_shader.compile(shaders, color_mgr=self._color_mgr) self.light_pdf_shader = self.shape.light_pdf(spec) self.light_pdf_shader.compile(shaders, color_mgr=self._color_mgr) self._emission_shader = self.material.emission_shader() self._emission_shader.compile(shaders, color_mgr=self._color_mgr) def prepare(self, runtimes): self.light_sample_shader.prepare(runtimes) ptrs = self.light_sample_shader.get_ptrs() args = [PointerArg('ptr_light_sample', p) for p in ptrs] lgt_sample = self.shader._get_arg('ptr_light_sample') lgt_sample.resize(args) self.light_pdf_shader.prepare(runtimes) ptrs = self.light_pdf_shader.get_ptrs() args = [PointerArg('ptr_light_pdf', p) for p in ptrs] lgt_pdf = self.emission_shader._get_arg('ptr_light_pdf') lgt_pdf.resize(args) self._emission_shader.prepare(runtimes) self.material.sync_shader_props(self._emission_shader) ptrs = self._emission_shader.get_ptrs() args = [PointerArg('ptr_mat_emission', p) for p in ptrs] ptr_emission = self.shader._get_arg('ptr_mat_emission') ptr_emission.resize(args) args = [PointerArg('ptr_mat_emission', p) for p in ptrs] ptr_emission = self.emission_shader._get_arg('ptr_mat_emission') ptr_emission.resize(args) self.shader.prepare(runtimes) self.emission_shader.prepare(runtimes) def get_value(self, name): if self.shader is None: raise ValueError("Light shader is not loaded!") return self.shader.get_value(name) def set_value(self, name, val): if self.shader is None: raise ValueError("Light shader is not loaded!") if isinstance(val, (RGBSpectrum, SampledSpectrum)): val = self._color_mgr.convert_spectrum(val, illum=True) self.shader.set_value(name, val)