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_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 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 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 _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 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 _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 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 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 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 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 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)
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 _rgb_to_rgb_spectrum_shader(rgb_mgr): code = """ return rgb(color[0], color[1], color[2]) """ vec = Vec3Arg('color', Vector3.zero()) shader = Shader(code=code, name='rgb_to_spectrum', func_args=[vec], is_func=True) return shader
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_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_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 isect_shader(cls, shader_name): code = """ temp1 = dot(ray.direction, rectangle.normal) if temp1 == 0.0: return 0 tmp = rectangle.point - ray.origin t = dot(tmp, rectangle.normal) / temp1 if t < 0.00001: return 0 if t > min_dist: return 0 p = ray.origin + ray.direction * t d = p - rectangle.point ddota = dot(d, rectangle.edge_a) if ddota < 0.0: return 0 if ddota > rectangle.edge_a_squared: return 0 ddotb = dot(d, rectangle.edge_b) if ddotb < 0.0: return 0 if ddotb > rectangle.edge_b_squared: return 0 hitpoint.t = t hitpoint.normal = rectangle.normal hitpoint.hit = p hitpoint.mat_idx = rectangle.mat_idx hitpoint.light_id = rectangle.light_id hitpoint.u = 0.0 hitpoint.v = 0.0 return 1 """ func_args = [ StructArgPtr('ray', Ray.factory()), StructArgPtr('rectangle', Rectangle.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 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 wrapped_f(*args, **kwargs): arguments = [] for arg in func_args: name, cls = arg a = argument_factory(name, cls) arguments.append(a) code = func(*args, **kwargs) name = func.__name__ return Shader(code=code, args=[], name=name, func_args=arguments, is_func=True)
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 _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)
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 _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 light_pdf(self, spectrum): area = (self.p1 - self.p0).cross(self.p2 - self.p0).length() * 0.5 inv_area = 1.0 / area code = """ shadepoint.light_pdf = inv_area """ inv_area = FloatArg('inv_area', inv_area) args = [inv_area] func_args = [StructArgPtr('hitpoint', HitPoint.factory()), StructArgPtr('shadepoint', ShadePoint.factory(spectrum))] name = 'triangle_light_pdf_%i' % id(self) return Shader(code=code, args=args, name=name, 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])