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()
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 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 intersect_ray_spheres_bool(n):
asm = util.get_asm()
mc = asm.assemble(ASM1)
runtime = Runtime()
#Sphere.intersectbool_asm(runtime, "ray_sphere_intersect")
Sphere.intersect_asm(runtime, "ray_sphere_intersect")
ds = runtime.load("test", mc)
for x in range(n):
sphere = generate_sphere()
ray = generate_ray()
ds["sph.origin"] = v4(sphere.origin)
ds["sph.radius"] = sphere.radius
ds["sph.mat_index"] = sphere.material
ds["r1.origin"] = v4(ray.origin)
ds["r1.dir"] = v4(ray.dir)
hp = sphere.intersect(ray, 999999.0)
runtime.run("test")
if hp is not False and ds["hit"] == 0:
print(hp.t, ds["t"], ds["hit"])
if hp is False and ds["hit"] == 1:
print(ds["t"], ds["hit"])
if hp is not False:
print_hitpoint(ds, hp)
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 isect_ray_triangle_array():
mc = renmas.utils.get_asm().assemble(ASM2)
runtime = Runtime()
renmas.shapes.Triangle.isect_asm(runtime, "triangle_isect")
renmas.shapes.intersect_ray_shape_array("triangle", runtime, "triangle_array", "triangle_isect")
ds = runtime.load("isect", mc)
return (runtime, ds)
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_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 setUp(self):
self.runtime = Runtime()
self.macro_call = mac.MacroCall()
self.macro_call.set_runtimes([self.runtime])
factory = renmas2.Factory()
self.assembler = factory.create_assembler()
self.assembler.register_macro('call', self.macro_call.macro_call)
def test_clamp():
mgr = ColorManager()
ASM = "\n #DATA \n " + mgr.spectrum_struct() + """
spectrum sp1
float low =0.25
float high = 0.35
#CODE
macro mov ebx, sp1
macro eq32 xmm0 = low
macro eq32 xmm1 = high
macro spectrum clamp ebx
#END
"""
mc = mgr.assembler.assemble(ASM)
#mc.print_machine_code()
runtime = Runtime()
ds = runtime.load("test", mc)
col = mgr.create_spectrum((0.3, 0.2, 0.4))
ds['sp1.values'] = col.to_ds()
runtime.run('test')
print(ds['sp1.values'])
col.clamp(low=0.25, high=0.35)
if col.sampled:
print(col)
else:
print(col.r, col.g, col.b)
pass
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)
ref_sam = renmas2.materials.PerfectSpecularSampling()
mat.add(ref_sam)
spec2 = ren.converter.create_spectrum((0.9, 0.9, 0.9))
fresnel2 = renmas2.materials.FresnelDielectric(eta_in, eta_out)
perf_ref = renmas2.materials.PerfectSpecular(spec2, fresnel2, 1.0)
mat.add(perf_ref)
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_bsdf_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_bsdf(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_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 isect_ray_sphere_array():
mc = renmas.utils.get_asm().assemble(ASM2)
runtime = Runtime()
renmas.shapes.Sphere.isect_asm(runtime, "sphere_isect")
renmas.shapes.intersect_ray_shape_array("sphere", runtime, "sphere_array", "sphere_isect")
ds = runtime.load("isect", mc)
return (runtime, ds)
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 performance_regular_sampler(width, height):
sam = RegularSampler(width, height)
runtimes = [Runtime(), Runtime(), Runtime(), Runtime()]
sam.prepare(runtimes)
sam.set_pass(0)
code = """
ret = 1
nsamples = 0
while ret != 0:
ret = generate_sample(sample)
if ret == 0:
break
nsamples = nsamples + 1
"""
sample = Sample(0.0, 0.0, 0, 0, 1.0)
props = {'sample': sample, 'ret': 0, 'nsamples': 0}
bas = BasicShader(code, props)
bas.prepare(runtimes, [sam.shader])
start = time.clock()
bas.execute()
end = time.clock()
print("Exectution of generating %i samples took %f" %
(bas.shader.get_value('nsamples'), end - start))
def test_isect_b(self):
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)
origin = Vector3(3.0, 2.5, 0.0)
direction = Vector3(0.0, 0.1, 0.88)
direction.normalize()
ray = Ray(origin, direction)
runtime = Runtime()
rectangle.isect_asm_b([runtime], "ray_rectangle_intersection")
assembler = create_assembler()
mc = assembler.assemble(self.asm_code_bool())
ds = runtime.load("test", mc)
Ray.populate_ds(ds, ray, 'ray1')
Rectangle.populate_ds(ds, rectangle, 'rec1')
runtime.run("test")
hp = rectangle.isect(ray)
if hp is False: self.assertFalse(ds["ret"]!=0)
if ds["ret"] == 0: self.assertFalse(hp)
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_sincos_ps(self):
asm = Tdasm()
mc = asm.assemble(SINCOS_CODE_PS)
runtime = Runtime()
load_math_func("fast_sincos_ps", runtime)
ds = runtime.load("sincos_ps", mc)
for x in range(1000):
num1 = random.random() * 2000
num2 = random.random() * 2000
num3 = random.random() * 2000
num4 = random.random() * 2000
ds["v1"] = (num1, num2, num3, num4)
runtime.run("sincos_ps")
rez_asm_sin = ds["v1"]
rez_asm_cos = ds["v2"]
rez_py1_sin = math.sin(num1)
rez_py2_sin = math.sin(num2)
rez_py3_sin = math.sin(num3)
rez_py4_sin = math.sin(num4)
rez_py1_cos = math.cos(num1)
rez_py2_cos = math.cos(num2)
rez_py3_cos = math.cos(num3)
rez_py4_cos = math.cos(num4)
self.assertAlmostEqual(rez_asm_sin[0], rez_py1_sin, 3)
self.assertAlmostEqual(rez_asm_sin[1], rez_py2_sin, 3)
self.assertAlmostEqual(rez_asm_sin[2], rez_py3_sin, 3)
self.assertAlmostEqual(rez_asm_sin[3], rez_py4_sin, 3)
self.assertAlmostEqual(rez_asm_cos[0], rez_py1_cos, 3)
self.assertAlmostEqual(rez_asm_cos[1], rez_py2_cos, 3)
self.assertAlmostEqual(rez_asm_cos[2], rez_py3_cos, 3)
self.assertAlmostEqual(rez_asm_cos[3], rez_py4_cos, 3)
def test_isect_b(self):
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)
origin = Vector3(3.0, 2.5, 0.0)
direction = Vector3(0.0, 0.1, 0.88)
direction.normalize()
ray = Ray(origin, direction)
runtime = Runtime()
rectangle.isect_asm_b([runtime], "ray_rectangle_intersection")
assembler = create_assembler()
mc = assembler.assemble(self.asm_code_bool())
ds = runtime.load("test", mc)
Ray.populate_ds(ds, ray, 'ray1')
Rectangle.populate_ds(ds, rectangle, 'rec1')
runtime.run("test")
hp = rectangle.isect(ray)
if hp is False: self.assertFalse(ds["ret"] != 0)
if ds["ret"] == 0: self.assertFalse(hp)
def test_pow_ps(self):
asm = Tdasm()
mc = asm.assemble(POW_CODE_PS)
runtime = Runtime()
load_math_func("fast_pow_ps", runtime)
ds = runtime.load("pow_ps", mc)
for x in range(1000):
num1 = random.random() * 3
num2 = random.random() * 3
num3 = random.random() * 3
num4 = random.random() * 3
num5 = random.random() * 3
num6 = random.random() * 3
num7 = random.random() * 3
num8 = random.random() * 3
ds["v1"] = (num1, num2, num3, num4)
ds["v2"] = (num5, num6, num7, num8)
runtime.run("pow_ps")
rez_asm = ds["v1"]
rez_py1 = math.pow(num1, num5)
rez_py2 = math.pow(num2, num6)
rez_py3 = math.pow(num3, num7)
rez_py4 = math.pow(num4, num8)
self.assertAlmostEqual(rez_asm[0], rez_py1, 1)
self.assertAlmostEqual(rez_asm[1], rez_py2, 1)
self.assertAlmostEqual(rez_asm[2], rez_py3, 1)
self.assertAlmostEqual(rez_asm[3], rez_py4, 1)
def test_sincos_ps(self):
asm = Tdasm()
mc = asm.assemble(SINCOS_CODE_PS)
runtime = Runtime()
load_math_func("fast_sincos_ps", runtime)
ds = runtime.load("sincos_ps", mc)
for x in range(1000):
num1 = random.random() * 2000
num2 = random.random() * 2000
num3 = random.random() * 2000
num4 = random.random() * 2000
ds["v1"] = (num1, num2, num3, num4)
runtime.run("sincos_ps")
rez_asm_sin = ds["v1"]
rez_asm_cos = ds["v2"]
rez_py1_sin = math.sin(num1)
rez_py2_sin = math.sin(num2)
rez_py3_sin = math.sin(num3)
rez_py4_sin = math.sin(num4)
rez_py1_cos = math.cos(num1)
rez_py2_cos = math.cos(num2)
rez_py3_cos = math.cos(num3)
rez_py4_cos = math.cos(num4)
self.assertAlmostEqual(rez_asm_sin[0], rez_py1_sin, 3)
self.assertAlmostEqual(rez_asm_sin[1], rez_py2_sin, 3)
self.assertAlmostEqual(rez_asm_sin[2], rez_py3_sin, 3)
self.assertAlmostEqual(rez_asm_sin[3], rez_py4_sin, 3)
self.assertAlmostEqual(rez_asm_cos[0], rez_py1_cos, 3)
self.assertAlmostEqual(rez_asm_cos[1], rez_py2_cos, 3)
self.assertAlmostEqual(rez_asm_cos[2], rez_py3_cos, 3)
self.assertAlmostEqual(rez_asm_cos[3], rez_py4_cos, 3)
def test_pow_ps(self):
asm = Tdasm()
mc = asm.assemble(POW_CODE_PS)
runtime = Runtime()
load_math_func("fast_pow_ps", runtime)
ds = runtime.load("pow_ps", mc)
for x in range(1000):
num1 = random.random() * 3
num2 = random.random() * 3
num3 = random.random() * 3
num4 = random.random() * 3
num5 = random.random() * 3
num6 = random.random() * 3
num7 = random.random() * 3
num8 = random.random() * 3
ds["v1"] = (num1, num2, num3, num4)
ds["v2"] = (num5, num6, num7, num8)
runtime.run("pow_ps")
rez_asm = ds["v1"]
rez_py1 = math.pow(num1, num5)
rez_py2 = math.pow(num2, num6)
rez_py3 = math.pow(num3, num7)
rez_py4 = math.pow(num4, num8)
self.assertAlmostEqual(rez_asm[0], rez_py1, 1)
self.assertAlmostEqual(rez_asm[1], rez_py2, 1)
self.assertAlmostEqual(rez_asm[2], rez_py3, 1)
self.assertAlmostEqual(rez_asm[3], rez_py4, 1)
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 intersect_ray_spheres_bool(n):
asm = util.get_asm()
mc = asm.assemble(ASM1)
runtime = Runtime()
#Sphere.intersectbool_asm(runtime, "ray_sphere_intersect")
Sphere.intersect_asm(runtime, "ray_sphere_intersect")
ds = runtime.load("test", mc)
for x in range(n):
sphere = generate_sphere()
ray = generate_ray()
ds["sph.origin"] = v4(sphere.origin)
ds["sph.radius"] = sphere.radius
ds["sph.mat_index"] = sphere.material
ds["r1.origin"] = v4(ray.origin)
ds["r1.dir"] = v4(ray.dir)
hp = sphere.intersect(ray, 999999.0)
runtime.run("test")
if hp is not False and ds["hit"] == 0:
print(hp.t, ds["t"], ds["hit"])
if hp is False and ds["hit"] == 1:
print(ds["t"], ds["hit"])
if hp is not False:
print_hitpoint(ds, hp)
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_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_assign1(self):
code = """
shadepoint.light_intensity = spectrum(0.25)
sample = sample_hemisphere()
sample = (0.6, 0.4, 0.8)
#w = hitpoint.normal
w = (2.3, 2.5, 8.8)
w = normalize(w)
tv = (0.0034, 1.0, 0.0071)
v = cross(tv, w)
v = normalize(v)
u = cross(v, w)
ndir = u * sample[0] + v * sample[1] + w * sample[2]
shadepoint.wi = normalize(ndir)
shadepoint.pdf = dot(w, shadepoint.wi) * 0.318309886
"""
props = {}
col_mgr = ColorManager(spectral=True)
brdf = SurfaceShader(code, props, col_mgr=col_mgr)
mat = Material(bsdf=brdf)
mgr = MaterialManager()
mgr.add('blue_velvet', mat)
runtime = Runtime()
runtime2 = Runtime()
runtimes = [runtime, runtime2]
#bs.prepare([runtime])
shader = mgr.prepare_bsdf('brdf', runtimes)
#print (bs.shader._code)
#bs.execute()
sh = ShadePoint()
code = """
hp = Hitpoint()
sp = Shadepoint()
brdf(hp, sp, 0)
spec = sp.light_intensity
wi = sp.wi
pdf = sp.pdf
"""
wi = Vector3(2, 2, 2)
spec = col_mgr.black()
props = {'spec': spec, 'wi': wi, 'pdf': 0.0}
bs = BasicShader(code, props, col_mgr=col_mgr)
bs.prepare(runtimes, shaders=[shader])
print (bs.shader._code)
bs.execute()
print(bs.shader.get_value('spec'))
print(bs.shader.get_value('wi'))
print(bs.shader.get_value('pdf'))
print(next_direction())
def __init__(self):
asm = Tdasm()
m = asm.assemble(MEMCPY)
self.r = Runtime()
self.ds = self.r.load("memcpy", m)
m2 = asm.assemble(BLTRGBA)
self.ds2 = self.r.load("bltrgba", m2)
m3 = asm.assemble(BLTFLOATRGBA)
self.ds3 = self.r.load("bltfloatrgba", m3)
def regular_sampler():
runtime = Runtime()
sampler = renmas2.samplers.RegularSampler(2, 2, pixel=1.0)
sampler.get_sample_asm([runtime], 'get_sample')
tile = renmas2.core.Tile(0, 0, 2, 2)
tile.split(1)
sampler.set_tile(tile)
asm = Tdasm()
mc = asm.assemble(ASM_CODE)
runtime.load("test", mc)
return (sampler, runtime, 'test')
def __init__(self, scene_key=0.18, saturation=0.6):
self._asm = create_assembler()
self._runtime = Runtime()
self._macro_call = macro_call = MacroCall()
self._asm.register_macro('call', macro_call.macro_call)
macro_call.set_runtimes([self._runtime])
self._reinhard_asm()
self._key = float(scene_key)
self._saturation = float(saturation)
def _conv_rgba_bgra_asm():
bits = platform.architecture()[0]
if bits == '64bit':
code = _conv_rgba_bgra_asm64()
else:
code = _conv_rgba_bgra_asm32()
mc = Tdasm().assemble(code)
runtime = Runtime()
ds = runtime.load("convert", mc)
return runtime, ds
def test_Y_rgb(self):
mgr = ColorManager(False)
runtime = Runtime()
mgr.Y_asm([runtime], 'luminance')
spec1 = mgr.create_spectrum((0.66,0.88, 0.11))
mc = create_assembler().assemble(self.asm_code1(mgr))
ds = runtime.load("test", mc)
ds["sp1.values"] = spec1.to_ds()
runtime.run("test")
self.assertAlmostEqual(mgr.Y(spec1), ds["Y"], 4)
def __init__(self, width, height, pitch, address):
self.addr = address
self.width = width
self.height = height
asm = Tdasm()
m = asm.assemble(ASM_STR)
self.r = Runtime()
self.ds = self.r.load("set_pixel", m)
self.ds["color"] = 0xFF00FF00 # red color is default
self.ds["address"] = address
self.ds["width"] = width
self.ds["height"] = height
self.ds["pitch"] = pitch
def test_Y_rgb(self):
mgr = ColorManager(False)
runtime = Runtime()
mgr.Y_asm([runtime], 'luminance')
spec1 = mgr.create_spectrum((0.66, 0.88, 0.11))
mc = create_assembler().assemble(self.asm_code1(mgr))
ds = runtime.load("test", mc)
ds["sp1.values"] = spec1.to_ds()
runtime.run("test")
self.assertAlmostEqual(mgr.Y(spec1), ds["Y"], 4)
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_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_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 __init__(self, m=0.6, c=0.5, a=0.5, f=1.0):
self._asm = create_assembler()
self._runtime = Runtime()
self._macro_call = macro_call = MacroCall()
self._asm.register_macro('call', macro_call.macro_call)
macro_call.set_runtimes([self._runtime])
self._photoreceptor_asm()
self._m = m # contrast range usually 0.2-0.9 - you can limit this 0.0-1.0
self._c = c # adaptation range 0.0-1.0
self._a = a # colornes-contrast range 0.0-1.0
self._f = f # lightnes
def test_atan(self):
asm = Tdasm()
mc = asm.assemble(ATAN_CODE)
runtime = Runtime()
load_math_func("fast_atan_ss", runtime)
ds = runtime.load("atan", mc)
for x in range(1000):
num = random.random() * 2000
ds["x"] = num
runtime.run("atan")
rez_asm = ds["x"]
rez_py = math.atan(num)
self.assertAlmostEqual(rez_asm, rez_py, 3)
def test_exp(self):
asm = Tdasm()
mc = asm.assemble(EXP_CODE)
runtime = Runtime()
load_math_func("fast_exp_ss", runtime)
ds = runtime.load("exp", mc)
for x in range(1000):
num = random.random() * 4
ds["x"] = num
runtime.run("exp")
rez_asm = ds["x"]
rez_py = math.exp(num)
self.assertAlmostEqual(rez_asm, rez_py, 2)
def test_exp(self):
asm = Tdasm()
mc = asm.assemble(EXP_CODE)
runtime = Runtime()
load_math_func("fast_exp_ss", runtime)
ds = runtime.load("exp", mc)
for x in range(1000):
num = random.random() * 4
ds["x"] = num
runtime.run("exp")
rez_asm = ds["x"]
rez_py = math.exp(num)
self.assertAlmostEqual(rez_asm, rez_py, 2)
def test_atan(self):
asm = Tdasm()
mc = asm.assemble(ATAN_CODE)
runtime = Runtime()
load_math_func("fast_atan_ss", runtime)
ds = runtime.load("atan", mc)
for x in range(1000):
num = random.random() * 2000
ds["x"] = num
runtime.run("atan")
rez_asm = ds["x"]
rez_py = math.atan(num)
self.assertAlmostEqual(rez_asm, rez_py, 3)
def test_log(self):
asm = Tdasm()
mc = asm.assemble(LOG_CODE)
runtime = Runtime()
load_math_func("fast_log_ss", runtime)
ds = runtime.load("log", mc)
for x in range(1000):
num = random.random()
ds["x"] = num
runtime.run("log")
rez_asm = ds["x"]
rez_py = math.log(num)
self.assertAlmostEqual(rez_asm, rez_py, 3)
def test_log(self):
asm = Tdasm()
mc = asm.assemble(LOG_CODE)
runtime = Runtime()
load_math_func("fast_log_ss", runtime)
ds = runtime.load("log", mc)
for x in range(1000):
num = random.random()
ds["x"] = num
runtime.run("log")
rez_asm = ds["x"]
rez_py = math.log(num)
self.assertAlmostEqual(rez_asm, rez_py, 3)
def build_runtime():
runtime = Runtime()
sam = renmas.samplers.RandomSampler(800, 800, n=200000, pixel=0.8)
sam.get_sample_asm(runtime, "get_sample")
ren.get_camera().ray_asm(runtime, "generate_ray")
renmas.shapes.linear_isect_asm(runtime, "scene_isect", ren.dyn_arrays())
renmas.shapes.visible_asm(runtime, "visible", "scene_isect")
renmas.core.generate_shade(runtime, "shade", "visible")
ren.get_film().add_sample_asm(runtime, "add_sample")
asm = renmas.utils.get_asm()
mc = asm.assemble(ASM)
ds = runtime.load("path_tracer", mc)
return (sam, runtime)
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_isect_b_sph(self):
sph_shader = Sphere.isect_b_shader()
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.prepare(runtimes)
shader.execute()
result = shader.get_value('p1')
self.assertEqual(result, 1)
def setUp(self):
self.runtime = Runtime()
self.macro_call = mac.MacroCall()
self.macro_call.set_runtimes([self.runtime])
factory = renmas2.Factory()
self.assembler = factory.create_assembler()
self.assembler.register_macro('call', self.macro_call.macro_call)
def test_pow(self):
asm = Tdasm()
mc = asm.assemble(POW_CODE)
runtime = Runtime()
load_math_func("fast_pow_ss", runtime)
ds = runtime.load("pow", mc)
for x in range(1000):
num = random.random() * 3
num1 = random.random() * 3
ds["x"] = num
ds["y"] = num1
runtime.run("pow")
rez_asm = ds["x"]
rez_py = math.pow(num, num1)
self.assertAlmostEqual(rez_asm, rez_py, 1)
def test_Y(self):
mgr = ColorManager(False)
runtime = Runtime()
mgr.XYZ_to_RGB_asm([runtime], 'XYZ_to_RGB')
mc = create_assembler().assemble(self.asm_code1())
ds = runtime.load("test", mc)
ds["XYZ"] = (0.69, 0.78, 0.88, 0.00)
runtime.run("test")
ret1 = ds["RGB"]
ret2 = mgr.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 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_chromacity_to_spectrum2(self):
mgr = ColorManager(spectral=True)
runtime = Runtime()
mgr.chromacity_to_spectrum_asm([runtime], 'chromacity_to_spectrum')
mc = create_assembler().assemble(self.asm_code1(mgr))
ds = runtime.load("test", mc)
ds['x'] = 0.45
ds['y'] = 0.41
spec = mgr.chromacity_to_spectrum(0.45, 0.41)
runtime.run("test")
vals = ds['sp1.values']
for i in range(len(vals)):
self.assertAlmostEqual(vals[i], spec.samples[i], 4)
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)
