def test_isect1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
irender = renmas2.IRender(ren)
#irender.add_shape(type="mesh", name="cube1", filename="I:/Ply_files/Horse97K.ply")
#irender.add_shape(type="mesh", name="cube1", filename="I:/Obj_files/auto1.obj")
triangle = factory.create_triangle(v0=(2, 2, 2),
v1=(5, 2, 2),
v2=(3.5, 5, 2))
ray = factory.create_ray(origin=(3, 2.5, 0), direction=(0, 0.1, 0.88))
ren.add("triangle1", triangle)
ray = factory.create_ray(origin=(10, 10, 10), direction=(-1, -1, -1))
ren.intersector.prepare()
ren.intersector.isect_asm([runtime], "ray_scene_intersection")
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
ren.intersector.visibility_asm([runtime],
"ray_scene_intersection_bool")
self.ray_ds(ds, ray, "ray1")
runtime.run("test")
print(ds["hp1.t"])
hp = ren.intersector.isect(ray)
print(hp.t)
def test_isect1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ply = renmas2.core.Ply()
ply.load("I:/Ply_files/Horse97K.ply")
vb = ply.vertex_buffer
tb = ply.triangle_buffer
mesh = factory.create_mesh(vb, tb)
mesh.isect_asm([runtime], "ray_smooth_mesh_intersection",
ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
for i in range(1000):
ray = self.random_ray()
self.ray_ds(ds, ray, "ray1")
self.smooth_mesh_ds(ds, mesh, "mesh1")
runtime.run("test")
hp = mesh.isect(ray)
if hp:
#print(hp.t, ds["hp1.t"])
n1 = hp.normal
n2 = ds["hp1.normal"]
self.assertAlmostEqual(n1.x, n2[0], 3)
self.assertAlmostEqual(n1.y, n2[1], 3)
self.assertAlmostEqual(n1.z, n2[2], 3)
def Dtest_isect2(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ply = renmas2.core.Ply()
ply.load("I:/Ply_files/cube.ply")
#ply.load("I:/Ply_files/dragon_vrip.ply")
vb = ply._vertex_buffer
tb = ply._triangle_buffer
mesh = factory.create_mesh(vb, tb)
triangles = self.create_triangle_list(vb, tb)
mesh.isect_asm([runtime], "ray_flat_mesh_intersection", ren.assembler,
ren.structures)
mc = ren.assembler.assemble(self.asm_code2(ren))
ds = runtime.load("test", mc)
for i in range(100):
ray = self.random_ray()
self.ray_ds(ds, ray, "ray1")
self.flat_mesh_ds(ds, mesh, "mesh1")
runtime.run("test")
hp = mesh.isect(ray)
if hp:
print(hp.t)
print(ds["hp1.t"])
print(ds["ret"])
def test_phong1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat = renmas2.core.material.Material(ren.converter.zero_spectrum())
spec = ren.converter.create_spectrum((0.2, 0.3, 0.1))
ren.macro_call.set_runtimes([runtime])
phong = factory.create_phong(spec, 2.0)
mat.add(phong)
t = 2.3
hit_point = factory.vector(2.2, 3.1, 4.4)
normal = factory.vector(2.9, 1.2, 4.5)
normal.normalize()
ray = factory.create_ray(origin=(4, 4, 4), direction=(6, 7, 8))
hp = renmas2.shapes.HitPoint(t, hit_point, normal, 0, ray)
wi = factory.vector(-6, 8, -3.8)
wi.normalize()
hp.wo = ray.dir * -1.0
hp.wi = wi
hp.ndotwi = normal.dot(wi)
mat.f_asm([runtime], ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
self.populate_ds(ds, hp)
ds["brdf_ptr"] = runtime.address_module(mat.f_asm_name)
runtime.run("test")
spectrum = mat.f(hp)
print(spectrum)
print(ds["hp.f_spectrum.values"])
def test_hemisphere_cos(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat1 = ren.shader.material("default")
sam = renmas2.materials.HemisphereCos(1.5)
mat1.add(sam)
normal = factory.vector(2, 4, 5)
normal.normalize()
hit_point = factory.vector(3, 5, 6)
hp = renmas2.shapes.HitPoint(1.5, hit_point, normal, 0)
ren.macro_call.set_runtimes([runtime])
mat1.next_direction_asm([runtime], ren.structures, ren.assembler)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["next_dir_ptr"] = runtime.address_module(mat1.nd_asm_name)
ds["hp.normal"] = (normal.x, normal.y, normal.z, 0.0)
ds["hp.t"] = 1.5
ds["hp.hit"] = (hit_point.x, hit_point.y, hit_point.z)
runtime.run("test")
print(ds['hp.wi'])
print(ds['hp.ndotwi'])
print(ds['hp.pdf'])
mat1.next_direction(hp)
print(hp.ndotwi)
print(hp.wi)
print(hp.pdf)
def test_addsample(self):
ren = renmas2.Renderer()
runtime = Runtime()
#ren.spectrum_rendering = True
ren.film.nsamples = 2
ren.prepare()
ren.converter.to_rgb_asm("spectrum_to_rgb", [runtime])
ren.film.add_sample_asm([runtime], "add_sample", "spectrum_to_rgb")
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
ds["sp1.ix"] = 10
ds["sp1.iy"] = 10
ds["sp1.xyxy"] = (10.4, 10.4, 10.4, 10.4)
sample = renmas2.samplers.Sample(10.4, 10.4, 10, 10, 0.5)
spec = ren.converter.create_spectrum((0.70, 0.2, 0.3))
ren.film.add_sample(sample, spec)
ds["spec1.values"] = spec.to_ds()
runtime.run("test")
ds["sp1.ix"] = 15
ds["sp1.iy"] = 19
ds["sp1.xyxy"] = (15.7, 19.4, 15.7, 19.4)
sample = renmas2.samplers.Sample(10.4, 10.4, 15, 19, 0.5)
spec = ren.converter.create_spectrum((0.50, 0.4, 0.1))
ren.film.add_sample(sample, spec)
ds["spec1.values"] = spec.to_ds()
runtime.run("test")
print(ren.film._ds[0]["temp"])
def test_isect1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
triangle = factory.create_triangle(v0=(2, 2, 2),
v1=(5, 2, 2),
v2=(3.5, 5, 2))
triangle = factory.create_triangle(v0=(3.64479, 19.4901, 31.67),
v1=(1.5157999, 0.6639999, 31.8798),
v2=(1.4469, 0.663999, 31.415))
ray = factory.create_ray(origin=(280.0, 110.0, 244.0),
direction=(-0.759278, -0.2980911,
-0.57847869))
#hp = triangle.isect(ray)
triangle.isect_asm([runtime], "ray_triangle_intersection",
ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
self.ray_ds(ds, ray, "ray1")
self.triangle_ds(ds, triangle, "tri1")
runtime.run("test")
self.intersect(ray, triangle, runtime, ds)
for i in range(1000):
r = self.random_ray()
t = self.random_triangle()
self.intersect(r, t, runtime, ds)
def test_shader1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
irender = renmas2.IRender(ren)
#ren.spectral_rendering = True
runtime = Runtime()
irender.add_light(type="pointlight",
name="light1",
source=(4.0, 4.0, 4.0),
position=(10.1, 10, 10))
irender.add_shape(type="sphere",
name="Sphere00",
radius=3.0,
position=(0.0, 0.0, 0.0))
ren.prepare()
ren.intersector.visibility_asm([runtime], "ray_scene_visibility")
ren.shader.shade_asm([runtime], "shade", "ray_scene_visibility")
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["hp.hit"] = (4.4, 2.2, 1.0, 0.0)
ds["hp.t"] = 2.2
ds["hp.normal"] = (0.0, 1.0, 0.0, 0.0)
ds["hp.mat_index"] = 0
runtime.run("test")
hit = renmas2.Vector3(4.4, 2.2, 1.0)
normal = renmas2.Vector3(0.0, 1.0, 0.0)
hp = renmas2.shapes.HitPoint(2.2, hit, normal, 0)
ret = ren.shader.shade(hp)
print(ret)
print(ds["hp.l_spectrum.values"])
def test_hemisphere_cos(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
spec = ren.converter.create_spectrum((0.2, 0.3, 0.1))
mat1 = renmas2.core.material.Material(ren.converter.zero_spectrum())
phong = factory.create_phong(spec, 2.0)
lam_sampling = renmas2.materials.LambertianSampling()
mat1.add(phong)
mat1.add(lam_sampling)
normal = factory.vector(2, 4, 5)
normal.normalize()
hit_point = factory.vector(3, 5, 6)
hp = renmas2.shapes.HitPoint(1.5, hit_point, normal, 0)
ren.macro_call.set_runtimes([runtime])
mat1.next_direction_asm([runtime], ren.structures, ren.assembler)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["next_dir_ptr"] = runtime.address_module(mat1.nd_asm_name)
ds["hp.normal"] = (normal.x, normal.y, normal.z, 0.0)
ds["hp.t"] = 1.5
ds["hp.hit"] = (hit_point.x, hit_point.y, hit_point.z)
runtime.run("test")
print(ds['hp.wi'])
print(ds['hp.ndotwi'])
print(ds['hp.pdf'])
mat1.next_direction(hp)
print(hp.ndotwi)
print(hp.wi)
print(hp.pdf)
def test_light_sample(self):
runtime = Runtime()
ren = renmas2.Renderer()
factory = renmas2.Factory()
rectangle = factory.create_rectangle(point=(0, 0, 55.92),
e1=(55.28, 0, 0),
e2=(0, 54.88, 0.0),
normal=(0.0, 0.0, -1.0))
ren.macro_call.set_runtimes([runtime])
mc = rectangle.light_sample_asm('light_rect', ren.assembler,
ren.structures)
ds_rect = runtime.load('light_sample_name', mc)
rectangle.populate_ds(ds_rect)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
runtime.run("test")
print(ds['hp.light_sample'])
print(ds['hp.light_normal'])
print(ds['hp.light_pdf'])
normal = factory.vector(2.9, 1.2, 4.5)
normal.normalize()
hit_point = factory.vector(2.2, 3.3, 4.4)
hp = renmas2.shapes.HitPoint(1.0, hit_point, normal, 0)
rectangle.light_sample(hp)
print(hp.light_sample)
print(hp.light_normal)
print(hp.light_pdf)
def test_transmission_sampling(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat = renmas2.core.material.Material(ren.converter.zero_spectrum())
eta_in = 1.3
eta_out = 1.0
sampling = renmas2.materials.PerfectTransmissionSampling(
eta_in, eta_out)
mat.add(sampling)
eta_in = ren.converter.zero_spectrum().set(1.3)
eta_out = ren.converter.zero_spectrum().set(1.0)
fresnel = renmas2.materials.FresnelDielectric(eta_in, eta_out)
spec = ren.converter.create_spectrum((0.5, 0.5, 0.5))
perf_spec = renmas2.materials.PerfectTransmission(spec, fresnel, 1.0)
mat.add(perf_spec)
normal = factory.vector(2, 4.5, 5)
normal.normalize()
hit_point = factory.vector(3, 5, 6)
wo = factory.vector(-2, 1, 0)
wo.normalize()
hp = renmas2.shapes.HitPoint(1.5, hit_point, normal, 0)
hp.wo = wo
hp.fliped = False
ren.macro_call.set_runtimes([runtime])
mat.next_direction_btdf_asm([runtime], ren.structures, ren.assembler)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["next_dir_ptr"] = runtime.address_module(mat.nd_asm_name)
ds["hp.normal"] = (normal.x, normal.y, normal.z, 0.0)
ds["hp.t"] = 1.5
ds["hp.hit"] = (hit_point.x, hit_point.y, hit_point.z, 0.0)
ds["hp.wo"] = (wo.x, wo.y, wo.z, 0.0)
ds["hp.fliped"] = 0
runtime.run("test")
mat.next_direction_btdf(hp)
print("Python")
print(hp.wi)
print(hp.ndotwi)
print(hp.specular)
print(hp.f_spectrum)
print("ASM")
print(ds["hp.wi"])
print(ds["hp.ndotwi"])
print(ds["hp.specular"])
print(ds["hp.f_spectrum.values"])
def test_isect(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
irender = renmas2.IRender(ren)
filename = 'C:\\Users\\Mario\\Desktop\\glass\\glass.py'
exec(compile(open(filename).read(), filename, 'exec'), dict(locals()),
dict(globals()))
ren.prepare()
ren.macro_call.set_runtimes([runtime])
ren.intersector.isect_asm([runtime], 'ray_scene_intersection')
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
camera = ren.camera
sampler = ren.sampler
for tile in ren._tiles3:
sampler.set_tile(tile)
while True:
sam = sampler.get_sample()
if sam is None: break
ray = camera.ray(sam)
self.ray_ds(ds, ray, "ray1")
runtime.run("test")
t = ds["hp1.t"]
hp = ren.intersector.isect(ray)
if hp is False: self.assertFalse(ds["ret"] != 0)
if ds["ret"] == 0: self.assertFalse(hp)
if hp is not False:
n1 = hp.normal
n2 = ds["hp1.normal"]
#print("Normal")
#print(n1)
#print(n2)
#print("Hit point")
#print(hp.hit_point)
#print(ds['hp1.hit'])
self.assertAlmostEqual(hp.t, t, 1)
print(t, hp.t)
print(n1)
print(n2)
self.assertAlmostEqual(n1.x, n2[0], 1)
self.assertAlmostEqual(n1.y, n2[1], 1)
self.assertAlmostEqual(n1.z, n2[2], 1)
def test_fresnel(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
silver = ren.spd.load("metal", "silver")
n = ren.converter.create_spectrum(silver[0])
k = ren.converter.create_spectrum(silver[1])
spec = ren.converter.create_spectrum([(500, 1.3), (600, 1.4),
(700, 1.5)])
print(spec)
n, k = renmas2.materials.FresnelConductor.conv_f0(n)
fresnel = renmas2.materials.FresnelConductor(n=n, k=k)
def test_isect1(self):
factory = renmas2.Factory()
ray = factory.create_ray(origin=(5,5,5), direction=(-1,-1,-1))
sphere = factory.create_sphere(origin=(0,0,0), radius=2)
ren = renmas2.Renderer()
runtime = Runtime()
sphere.isect_asm([runtime], "ray_sphere_intersection", ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
self.intersect(ray, sphere, runtime, ds)
for i in range(10000):
r = self.random_ray()
s = self.random_sphere()
self.intersect(r, s, runtime, ds)
def Atest_isect1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ply = renmas2.core.Ply()
ply.load("I:/Ply_files/cube.ply")
#ply.load("I:/Ply_files/dragon_vrip.ply")
#ply.load("I:/Ply_files/xyzrgb_dragon.ply")
#ply.load("I:/Ply_files/lucy.ply")
vb = ply._vertex_buffer
tb = ply._triangle_buffer
mesh = factory.create_mesh(vb, tb)
triangles = self.create_triangle_list(vb, tb)
#self.intersection_tests(10, triangles, mesh)
mesh._isect_triangles_asm([runtime], "ray_triangles_idx",
ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ray = self.random_ray()
self.ray_ds(ds, ray, "ray1")
self.flat_mesh_ds(ds, mesh, "mesh1")
addr = mesh._grid._get_addr_in_array(0, 1, 2)
print(addr)
ds["ptr_triangles_arr"] = addr
ntri = x86.GetUInt32(addr, 0, 0)
triangles = x86.GetUInt32(addr + 4, 0, ntri)
hp = mesh.isect_triangles(ray, triangles)
print(hp)
if hp:
print("t=", hp.t)
print("hit=", hp.hit_point)
print("normala=", hp.normal)
print(ntri)
print(triangles)
runtime.run("test")
print("ret", ds["ret"])
print("t= ", ds["t"])
print("hit=", ds["hit"])
print("normala", ds["normal"])
start = time.clock()
#self.speed_test(20, triangles, mesh)
end = time.clock()
def test_visibility1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
for i in range(2):
self.add_rnd_sphere(ren)
ren.prepare()
ren.intersector.visibility_asm([runtime], "ray_scene_visibility")
mc = ren.assembler.assemble(self.asm_code2(ren))
ds = runtime.load("test", mc)
p1 = renmas2.Vector3(random(), random(), random())
p2 = renmas2.Vector3(random(), random(), random())
self.intersect2(runtime, ds, ren.intersector, p1, p2)
def test_lamb1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat = renmas2.core.material.Material(ren.converter.zero_spectrum())
#mat.f_asm([runtime], ren.assembler, ren.structures)
mat1 = ren.shader.material("default")
mat1.f_asm([runtime], ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["brdf_ptr"] = runtime.address_module(mat1.f_asm_name)
runtime.run("test")
print(ds["hp.f_spectrum.values"])
def test_Y(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ren.spectral_rendering = True
conv = ren.converter
conv.Y_asm("lumminance", [runtime])
spec1 = conv.create_spectrum((0.66, 0.88, 0.11))
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["sp1.values"] = spec1.to_ds()
runtime.run("test")
self.assertAlmostEqual(conv.Y(spec1), ds["Y"], 4)
def test_perfect_specular(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat = renmas2.core.material.Material(ren.converter.zero_spectrum())
spec = ren.converter.create_spectrum((1.0, 1.0, 1.0))
ren.macro_call.set_runtimes([runtime])
eta_in = ren.converter.zero_spectrum().set(1.5)
eta_out = ren.converter.zero_spectrum().set(1.0)
fresnel = renmas2.materials.FresnelDielectric(eta_in, eta_out)
perf_spec = renmas2.materials.PerfectSpecular(spec, fresnel, 1.0)
mat.add(perf_spec)
t = 2.3
hit_point = factory.vector(2.2, 3.1, 4.4)
normal = factory.vector(2.9, 1.2, 4.5)
normal.normalize()
hp = renmas2.shapes.HitPoint(t, hit_point, normal, 0)
wi = factory.vector(6, -27, 3.8)
wi.normalize()
wo = factory.vector(2, 2, 4)
wo.normalize()
hp.wo = wo
hp.wi = wi
hp.ndotwi = normal.dot(wi)
print(hp.ndotwi)
hp.fliped = True
hp.specular = 89
mat.f_asm([runtime], ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
self.populate_ds(ds, hp)
ds["brdf_ptr"] = runtime.address_module(mat.f_asm_name)
runtime.run("test")
spectrum = mat.f(hp)
print("shlick", self.shlick(1.5, hp.ndotwi))
print("Python")
print(spectrum)
print("---------------------------------------")
print("Asm")
print(ds["hp.f_spectrum.values"])
def test_conversion(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ren.spectral_rendering = True
conv = ren.converter
conv.chromacity_to_spectrum_asm("chromacity_to_spectrum", [runtime])
spec = conv.chromacity_to_spectrum(0.35, 0.25)
print(spec)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds['x'] = 0.35
ds['y'] = 0.25
runtime.run('test')
print(ds['spec.values'])
def test_linear1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
for i in range(100):
self.add_rnd_sphere(ren)
self.add_rnd_triangle(ren)
ren.prepare()
ren.intersector.isect_asm([runtime], "ray_scene_intersection")
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
ray = self.random_ray()
for i in range(1000):
ray = self.random_ray()
self.intersect(ray, runtime, ds, ren.intersector)
def test_isect1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
rectangle = factory.create_rectangle(point=(0, 0, 55.92),
e1=(55.28, 0, 0),
e2=(0, 54.88, 0.0),
normal=(0.0, 0.0, -1.0))
ray = factory.create_ray(origin=(3, 2.5, 0), direction=(0, 0.1, 0.88))
hp = rectangle.isect(ray)
rectangle.isect_asm([runtime], "ray_rectangle_intersection",
ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
self.intersect(ray, rectangle, runtime, ds)
def abc_test_isect2(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
triangle = factory.create_triangle(v0=(2, 2, 2),
v1=(5, 2, 2),
v2=(3.5, 5, 2))
ray = factory.create_ray(origin=(3, 2.5, 0), direction=(0, 0.1, 0.88))
triangle.isect_asm_b([runtime], "ray_sphere_intersection",
ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code2(ren))
ds = runtime.load("test", mc)
self.intersect2(ray, triangle, runtime, ds)
for i in range(10000):
r = self.random_ray()
t = self.random_triangle()
self.intersect2(r, t, runtime, ds)
def test_grid_performance(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
irender = renmas2.IRender(ren)
filename = 'I:\\GitRENMAS\\scenes\\mini_moris.py'
exec(compile(open(filename).read(), filename, 'exec'), dict(locals()),
dict(globals()))
ren.prepare()
ren.macro_call.set_runtimes([runtime])
ren.intersector.isect_asm([runtime], 'ray_scene_intersection')
mc = ren.assembler.assemble(self.asm_code(ren))
ds = runtime.load("test", mc)
ren.sampler.set_tile(ren._tiles3[0])
while True:
sam = ren.sampler.get_sample()
if sam is None: break
if sam.iy == 105:
if sam.ix == 188:
ray = ren.camera.ray(sam)
self.ray_ds(ds, ray, "ray1")
start = time.clock()
runtime.run("test")
end = time.clock() - start
print("Time:", end)
print("Counter1", ds["counter1"])
print("Counter2", ds["counter2"])
print("Counter3", ds["counter3"])
print("tx_next", ds["tx_next"])
print("ty_next", ds["ty_next"])
print("tz_next", ds["tz_next"])
print("temp", ds["temp"])
break
hp = ren.intersector.isect(ray)
if hp:
print("intersection ocur")
else:
print("no intersection ocur")
def test_Y(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ren.spectral_rendering = True
conv = ren.converter
conv.xyz_to_rgb_asm("xyz_to_rgb", [runtime], ren.assembler)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["XYZ"] = (0.69, 0.78, 0.88, 0.00)
runtime.run("test")
ret1 = ds["RGB"]
ret2 = ren.converter.xyz_to_rgb(0.69, 0.78, 0.88)
self.assertAlmostEqual(ret1[0], ret2[0], 4)
self.assertAlmostEqual(ret1[1], ret2[1], 4)
self.assertAlmostEqual(ret1[2], ret2[2], 4)
def test_conversion(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ren.spectral_rendering = True
conv = ren.converter
conv.rgb_to_spectrum_asm("rgb_to_spectrum", [runtime])
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds['rgb'] = (0.53, 0.46, 0.15, 0.0)
runtime.run('test')
print("Konverzija")
spec = conv.rgb_to_sampled((0.53, 0.46, 0.15))
print(spec)
print(ds['spec.values'])
def test_getsky(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
ren.spectral_rendering = True
ren.macro_call.set_runtimes([runtime])
sk = renmas2.lights.SunSky(renderer=ren, latitude=80.0, longitude=43.0, sm=0, jd=224, time_of_day=16.50, turbidity=3.0)
direction = renmas2.Vector3(3.2, 0.01, 1.8)
direction.normalize()
sk.get_sky_spectrum_asm('get_sky_spectrum', [runtime])
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds['dir'] = (direction.x, direction.y, direction.z, 0.0)
ds['spec.values'] = ren.converter.zero_spectrum().set(1.0).to_ds()
runtime.run('test')
spec = sk.get_sky_spectrum(direction)
print(spec)
print(ds['spec.values'])
def test_perfect_sampling(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat = renmas2.core.material.Material(ren.converter.zero_spectrum())
sam = renmas2.materials.PerfectSpecularSampling()
mat.add(sam)
normal = factory.vector(2, 4.5, 5)
normal.normalize()
hit_point = factory.vector(3, 5, 6)
wo = factory.vector(-2, 1, 0)
wo.normalize()
hp = renmas2.shapes.HitPoint(1.5, hit_point, normal, 0)
hp.wo = wo
ren.macro_call.set_runtimes([runtime])
mat.next_direction_asm([runtime], ren.structures, ren.assembler)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
ds["next_dir_ptr"] = runtime.address_module(mat.nd_asm_name)
ds["hp.normal"] = (normal.x, normal.y, normal.z, 0.0)
ds["hp.t"] = 1.5
ds["hp.hit"] = (hit_point.x, hit_point.y, hit_point.z, 0.0)
ds["hp.wo"] = (wo.x, wo.y, wo.z, 0.0)
runtime.run("test")
print("PDF =", hp.pdf)
print("wi =", hp.wi)
print("ndotwi =", hp.ndotwi)
mat.next_direction(hp)
print("PDF =", hp.pdf, " ASM pdf = ", ds["hp.pdf"])
print("wi =", hp.wi)
print("asm wi", ds["hp.wi"])
print("ndotwi =", hp.ndotwi, " asm ndtowi=", ds["hp.ndotwi"])
print("normal=", hp.normal)
def test_ward1(self):
factory = renmas2.Factory()
ren = renmas2.Renderer()
runtime = Runtime()
mat = renmas2.core.material.Material(ren.converter.zero_spectrum())
spec = ren.converter.create_spectrum((0.2, 0.3, 0.1))
ren.macro_call.set_runtimes([runtime])
ward = factory.create_ward(spec, 0.1, 1.0)
mat.add(ward)
t = 2.3
hit_point = factory.vector(2.2, 3.1, 4.4)
normal = factory.vector(2.9, 1.2, 4.5)
normal.normalize()
hp = renmas2.shapes.HitPoint(t, hit_point, normal, 0)
wi = factory.vector(6,-8,3.8)
wi.normalize()
wo = factory.vector(2, 2, 4)
wo.normalize()
hp.wo = wo
hp.wi = wi
hp.ndotwi = normal.dot(wi)
mat.f_asm([runtime], ren.assembler, ren.structures)
mc = ren.assembler.assemble(self.asm_code1(ren))
ds = runtime.load("test", mc)
self.populate_ds(ds, hp)
ds["brdf_ptr"] = runtime.address_module(mat.f_asm_name)
runtime.run("test")
spectrum = mat.f(hp)
print("Python")
print(spectrum)
print("---------------------------------------")
print("Asm")
print(ds["hp.f_spectrum.values"])
import renmas2
renderer = renmas2.Renderer()
spd = renderer.spd
#ret = spd.load("light", "A")
#ret = spd.load("real_object", "cotton_shirt")
ret = spd.load("metal", "silver")
print(ret)
