def test_assign1(self):
code = """
v2[1] = v1[0]
p1.position[2] = p1.size[0]
"""
p1 = Point(Vector3(2.2, 4.4, 7.7), Vector2(3.3, 5.5),
Vector4(1.1, 2.2, 3.3, 4.4))
props = {
'v1': Vector2(8.3, 6.0),
'v2': Vector3(5.6, 3.3, 2.2),
'v3': Vector4(4.4, 6.6, 2.2, 9.9),
'ret': 0.0,
'p1': p1
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val1 = bs.shader.get_value('v2')
val2 = bs.shader.get_value('v1')
self.assertAlmostEqual(val1.y, val2.x, places=5)
val1 = bs.shader.get_value('p1.position')
val2 = bs.shader.get_value('p1.size')
self.assertAlmostEqual(val1.z, val2.x, places=5)
def random_ray(ds):
origin = Vector3(0.0, 0.0, 0.0)
direction = Vector3(random(), random(), random())
direction.normalize()
ray = Ray(origin, direction)
ray_ds(ds, ray, 'ray1')
return ray
def test_min(self):
code = """
ret = min(v1, v2)
ret2 = min(r1, r2)
"""
v1 = Vector3(0.3, 0.2, 0.4)
v2 = Vector3(0.1, 0.2, 0.5)
ret = Vector3(0.0, 0.0, 0.0)
r1 = 0.3
r2 = 0.6
ret2 = 0.0
props = {'ret':ret, 'v1':v1, 'v2':v2, 'r1':r1, 'r2':r2,
'ret2':ret2}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('ret')
self.assertAlmostEqual(val.x, min(v1.x, v2.x), 5)
self.assertAlmostEqual(val.y, min(v1.y, v2.y), 5)
self.assertAlmostEqual(val.z, min(v1.z, v2.z), 5)
val = bs.shader.get_value('ret2')
self.assertAlmostEqual(val, min(r1, r2), 5)
def test_arith1(self):
code = """
r1 = a1 + a2
r2 = a1 * a2
r3 = a4 * (0.5, 0.5)
r4 = a5 / (0.5, 0.5, 0.5)
r5 = (7,7,7,7) + a6
r6 = a3 / 3
r7 = a7 % 18
"""
props = {
'a1': 1.1,
'a2': 2.2,
'r1': 1.1,
'r2': 3.3,
'a3': 55,
'a4': Vector2(2.2, 4),
'a5': Vector3(5, 6, 7),
'a6': Vector4(3, 4, 5, 6),
'r3': Vector2(3, 4),
'r4': Vector3(1, 1, 1),
'r5': Vector4(11, 1, 1, 1),
'r6': 88,
'a7': 789,
'r7': 1
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('r1')
self.assertAlmostEqual(val, 2.2 + 1.1, places=5)
val = bs.shader.get_value('r2')
self.assertAlmostEqual(val, 1.1 * 2.2, places=5)
val = bs.shader.get_value('r3')
self.assertAlmostEqual(val.x, 2.2 * 0.5, places=5)
self.assertAlmostEqual(val.y, 4.0 * 0.5, places=5)
val = bs.shader.get_value('r4')
self.assertAlmostEqual(val.x, 5 * 2.0, places=5)
self.assertAlmostEqual(val.y, 6 * 2.0, places=5)
self.assertAlmostEqual(val.z, 7 * 2.0, places=5)
val = bs.shader.get_value('r5')
self.assertAlmostEqual(val.x, 7 + 3.0, places=5)
self.assertAlmostEqual(val.y, 7 + 4.0, places=5)
self.assertAlmostEqual(val.z, 7 + 5.0, places=5)
self.assertAlmostEqual(val.w, 7 + 6.0, places=5)
val = bs.shader.get_value('r6')
self.assertEqual(val, 55 // 3)
val = bs.shader.get_value('r7')
self.assertEqual(val, 789 % 18)
def _calc_sun_position(self):
t1 = 0.170 * sin(4 * pi * (self._jd - 80) / 373.0)
t2 = -0.129 * sin(2 * pi * (self._jd - 8) / 355.0)
t3 = (self._sm - self._longitude) / 15.0
solar_time = self._time_of_day + t1 + t2 + t3
solar_declination = 0.4093 * sin(2 * pi * (self._jd - 81) / 368.0)
solar_altitude = asin(
sin(radians(self._latitude)) * sin(solar_declination) -
cos(radians(self._latitude)) * cos(solar_declination) *
cos(pi * solar_time / 12.0))
self._theta_sun = theta_sun = pi / 2.0 - solar_altitude
opp = -cos(solar_declination) * sin(pi * solar_time / 12.0)
adj = -cos(radians(self._latitude)) * sin(solar_declination) + sin(
radians(self._latitude)) * cos(solar_declination) * cos(
pi * solar_time / 12.0)
solar_azimuth = atan2(opp, adj)
self._phi_sun = phi_sun = -solar_azimuth
self._dir_to_sun = Vector3(
cos(phi_sun) * sin(theta_sun),
sin(phi_sun) * sin(theta_sun), cos(theta_sun))
def math_fun_test(self, fun, py_fun):
num = random()
nums = (random(), random())
line1 = "ret = %s(%f)\n" % (fun, num)
line2 = "ret2 = %s((%f, %f))\n" % (fun, nums[0], nums[1])
code = line1 + line2
props = {
'ret': 1.1,
'ret2': Vector2(2.2, 4),
'ret3': Vector3(5, 6, 7),
'ret4': Vector4(11, 1, 1, 1)
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('ret')
self.assertAlmostEqual(val, py_fun(num), places=3)
val = bs.shader.get_value('ret2')
self.assertAlmostEqual(val.x, py_fun(nums[0]), places=3)
self.assertAlmostEqual(val.y, py_fun(nums[1]), places=3)
def test_pow(self):
code = """
ret = pow(1.4, 4.4)
ret2 = pow((1.1, 1.25), (2.1, 3.1))
ret3 = pow((1.3, 1.7, 1.8), (1.11, 2.11, 1.45))
ret4 = pow((1.9, 1.15, 2.11, 2.22), (1.77, 2.21, 2.5, 2.71))
"""
props = {
'ret': 1.1,
'ret2': Vector2(2.2, 4),
'ret3': Vector3(5, 6, 7),
'ret4': Vector4(11, 1, 1, 1)
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('ret')
self.assertAlmostEqual(val, pow(1.4, 4.4), places=3)
val = bs.shader.get_value('ret2')
self.assertAlmostEqual(val.x, pow(1.1, 2.1), places=3)
self.assertAlmostEqual(val.y, pow(1.25, 3.1), places=3)
val = bs.shader.get_value('ret3')
self.assertAlmostEqual(val.x, pow(1.3, 1.11), places=3)
self.assertAlmostEqual(val.y, pow(1.7, 2.11), places=3)
self.assertAlmostEqual(val.z, pow(1.8, 1.45), places=3)
val = bs.shader.get_value('ret4')
self.assertAlmostEqual(val.x, pow(1.9, 1.77), places=3)
self.assertAlmostEqual(val.y, pow(1.15, 2.21), places=3)
self.assertAlmostEqual(val.z, pow(2.11, 2.5), places=3)
self.assertAlmostEqual(val.w, pow(2.22, 2.71), places=3)
def test_arith2(self):
code = """
r1 = a1 + 5
r2 = 4 * a2
r3 = 8 * a4
r4 = a5 * 1.1
r5 = a6 * 0.5
"""
props = {
'a1': 1.1,
'a2': 2.2,
'r1': 1.1,
'r2': 3.3,
'a3': 55,
'a4': Vector2(2.2, 4),
'a5': Vector3(5, 6, 7),
'a6': Vector4(3, 4, 5, 6),
'r3': Vector2(3, 4),
'r4': Vector3(1, 1, 1),
'r5': Vector4(11, 1, 1, 1)
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('r1')
self.assertAlmostEqual(val, 1.1 + 5, places=5)
val = bs.shader.get_value('r2')
self.assertAlmostEqual(val, 4 * 2.2, places=5)
val = bs.shader.get_value('r3')
self.assertAlmostEqual(val.x, 8 * 2.2, places=5)
self.assertAlmostEqual(val.y, 8 * 4.0, places=5)
val = bs.shader.get_value('r4')
self.assertAlmostEqual(val.x, 1.1 * 5, places=5)
self.assertAlmostEqual(val.y, 1.1 * 6, places=5)
self.assertAlmostEqual(val.z, 1.1 * 7, places=5)
val = bs.shader.get_value('r5')
self.assertAlmostEqual(val.x, 0.5 * 3, places=5)
self.assertAlmostEqual(val.y, 0.5 * 4, places=5)
self.assertAlmostEqual(val.z, 0.5 * 5, places=5)
self.assertAlmostEqual(val.w, 0.5 * 6, places=5)
def test_isect1(self):
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)
runtime = Runtime()
assembler = create_assembler()
sphere.isect_asm([runtime], "ray_sphere_intersection")
mc = assembler.assemble(self.asm_code())
ds = runtime.load("test", mc)
self.intersect(ray, sphere, runtime, ds)
for i in range(100):
r = self.random_ray()
s = self.random_sphere()
self.intersect(r, s, runtime, ds)
def test_arith1(self):
code = """
ret = dot(v1, v2)
"""
v1 = Vector3(0.3, 0.2, 0.4)
v2 = Vector3(0.1, 0.2, 0.5)
props = {'ret':0.0, 'v1':v1, 'v2':v2}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('ret')
val2 = v1.dot(v2)
self.assertAlmostEqual(val, val2, 4)
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 test_assign1(self):
code = """
m1 = 77
a = m1
m1 = -45
b = m1
m1 = 3.4
c = m1
m1 = -8.8
d = m1
m1 = (-8, 5.1)
e = m1
m1 = (-1, 2.25, 7)
f = m1
m1 = (8, -2.33, -7, 1)
k = m1
"""
props = {
'aa': 333,
'a': 111,
'b': 250,
'c': 4.4,
'd': 1.1,
'e': Vector2(2.3, 6.0),
'f': Vector3(5.6, 3.3, 2.2),
'k': Vector4(4.4, 6.6, 2.2, 9.9)
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('a')
self.assertEqual(77, val)
val = bs.shader.get_value('b')
self.assertEqual(-45, val)
val = bs.shader.get_value('c')
self.assertAlmostEqual(val, 3.4, places=5)
val = bs.shader.get_value('d')
self.assertAlmostEqual(val, -8.8, places=5)
val = bs.shader.get_value('e')
self.assertAlmostEqual(val.x, -8.0, places=5)
self.assertAlmostEqual(val.y, 5.1, places=5)
val = bs.shader.get_value('f')
self.assertAlmostEqual(val.x, -1.0, places=5)
self.assertAlmostEqual(val.y, 2.25, places=5)
self.assertAlmostEqual(val.z, 7.0, places=5)
val = bs.shader.get_value('k')
self.assertAlmostEqual(val.x, 8.0, places=5)
self.assertAlmostEqual(val.y, -2.33, places=5)
self.assertAlmostEqual(val.z, -7.0, places=5)
self.assertAlmostEqual(val.w, 1.0, places=5)
def gen_vectors():
v0 = Vector3(random() * 3, random() * 3, random() * 3)
v1 = Vector3(random() * 3, random() * 3, random() * 3)
v2 = Vector3(random(), random(), random())
origin = Vector3(0, 0, 0)
direction = Vector3(random(), random(), random())
direction.normalize()
v0 = Vector3(2.2, 4.4, 6.6)
v1 = Vector3(1.1, 1.1, 1.1)
v2 = Vector3(5.1, -1.1, 5.1)
origin = Vector3(0.0, 0.0, 0.0)
direction = Vector3(3.0, 3.0,
3.02) #3.00 -- precission problem investigate
direction.normalize()
return (v0, v1, v2, origin, direction)
def test_arith1(self):
code = """
ret = cross(v1, v2)
"""
v1 = Vector3(0.32, 0.27, 0.45)
v2 = Vector3(0.111, 0.22, 0.533)
ret = Vector3(0.1, 0.2, 0.5)
props = {'ret':ret, 'v1':v1, 'v2':v2}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('ret')
val2 = v1.cross(v2)
self.assertAlmostEqual(val.x, val2.x, 4)
self.assertAlmostEqual(val.y, val2.y, 4)
self.assertAlmostEqual(val.z, val2.z, 4)
def next_direction():
w = Vector3(2.3, 2.5, 8.8)
w.normalize()
#w = hitpoint.normal
tv = Vector3(0.0034, 1.0, 0.0071)
v = tv.cross(w)
v.normalize()
u = v.cross(w)
pu = 0.6
pv = 0.4
pw = 0.8
ndir = u * pu + v * pv + w * pw
ndir.normalize()
pdf = w.dot(ndir) * 0.318309886
return ndir, pdf
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_const1(self):
pass
code = """
a = 555
b = -36
c = 2.3
d = -9.8
e = (2.3, 5)
f = (2.2, 4.77, -2.66)
k = (-1.23, 1.44, 9, 7.7)
"""
props = {
'a': 111,
'b': 250,
'c': 4.4,
'd': 1.1,
'e': Vector2(2.3, 6.0),
'f': Vector3(5.6, 3.3, 2.2),
'k': Vector4(4.4, 6.6, 2.2, 9.9)
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('a')
val2 = bs.shader.get_value('b')
val3 = bs.shader.get_value('c')
val4 = bs.shader.get_value('d')
self.assertEqual(555, val)
self.assertEqual(-36, val2)
self.assertAlmostEqual(val3, 2.3, places=5)
self.assertAlmostEqual(val4, -9.8, places=5)
val5 = bs.shader.get_value('e')
self.assertAlmostEqual(val5.x, 2.3, places=5)
self.assertAlmostEqual(val5.y, 5.0, places=5)
val6 = bs.shader.get_value('f')
self.assertAlmostEqual(val6.x, 2.2, places=5)
self.assertAlmostEqual(val6.y, 4.77, places=5)
self.assertAlmostEqual(val6.z, -2.66, places=5)
val7 = bs.shader.get_value('k')
self.assertAlmostEqual(val7.x, -1.23, places=5)
self.assertAlmostEqual(val7.y, 1.44, places=5)
self.assertAlmostEqual(val7.z, 9.0, places=5)
self.assertAlmostEqual(val7.w, 7.7, places=5)
def test_arith1(self):
code = """
r1 = a1 + a3 * 8.0
r4 = a5 - 0.2 * (8, 8, 8)
"""
props = {'a1':1.1, 'a2':2.2, 'r1':1.1, 'r2':3.3,
'a3':55, 'a4':Vector2(2.2, 4), 'a5':Vector3(5,6,7),
'a6':Vector4(3,4,5,6), 'r3':Vector2(3,4), 'r4':Vector3(1,1,1),
'r5':Vector4(11,1,1,1), 'r6':88, 'a7':789, 'r7':1}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('r1')
self.assertAlmostEqual(val, 1.1 + 55 * 8.0, places=4)
val = bs.shader.get_value('r4')
self.assertAlmostEqual(val.x, 5 - 0.2 * 8, places=4)
self.assertAlmostEqual(val.y, 6 - 0.2 * 8, places=4)
self.assertAlmostEqual(val.z, 7 - 0.2 * 8, places=4)
def test_assign2(self):
register_user_type(Point)
p1 = Point(33, 77, 99, 3.5, Vector3(2.2, 4.4, 7.7), Vector2(3.3, 5.5),
Vector4(1.1, 2.2, 3.3, 4.4))
code = """
idx = p1.idx
p1.x = 55
pp = 555
p1.y = pp
g = 4.8
p1.radius = g
g = (4,5,6)
p1.position = g
p1.size = (6,7)
p1.pp = (8,1,3,4)
"""
props = {'p1': p1, 'idx': 44}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('idx')
self.assertEqual(33, val)
val = bs.shader.get_value('p1.x')
self.assertEqual(55, val)
val = bs.shader.get_value('p1.y')
self.assertEqual(555, val)
val = bs.shader.get_value('p1.radius')
self.assertAlmostEqual(val, 4.8, places=5)
val = bs.shader.get_value('p1.position')
self.assertAlmostEqual(val.x, 4.0, places=5)
self.assertAlmostEqual(val.y, 5.0, places=5)
self.assertAlmostEqual(val.z, 6.0, places=5)
val = bs.shader.get_value('p1.size')
self.assertAlmostEqual(val.x, 6.0, places=5)
self.assertAlmostEqual(val.y, 7.0, places=5)
val = bs.shader.get_value('p1.pp')
self.assertAlmostEqual(val.x, 8.0, places=5)
self.assertAlmostEqual(val.y, 1.0, places=5)
self.assertAlmostEqual(val.z, 3.0, places=5)
self.assertAlmostEqual(val.w, 4.0, places=5)
def test_float1(self):
v = Vector2(1, 1)
v2 = Vector2(1, 1)
v3 = Vector3(1, 1, 1)
v4 = Vector4(1, 1, 1, 1)
code = """
ret = float2(5,6)
ret2 = float2(aa, bb)
ret3 = float3(8,9.5,3)
temp = (8,9,1,2)
ret4 = float4(temp[1],5.3,6, aa)
"""
props = {
'aa': 3.4,
'bb': 77,
'ret': v,
'ret2': v2,
'ret3': v3,
'ret4': v4
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('ret')
self.assertAlmostEqual(val.x, 5.0, places=5)
self.assertAlmostEqual(val.y, 6.0, places=5)
val = bs.shader.get_value('ret2')
self.assertAlmostEqual(val.x, 3.4, places=5)
self.assertAlmostEqual(val.y, 77.0, places=5)
val = bs.shader.get_value('ret3')
self.assertAlmostEqual(val.x, 8.0, places=5)
self.assertAlmostEqual(val.y, 9.5, places=5)
self.assertAlmostEqual(val.z, 3.0, places=5)
val = bs.shader.get_value('ret4')
self.assertAlmostEqual(val.x, 9.0, places=5)
self.assertAlmostEqual(val.y, 5.3, places=5)
self.assertAlmostEqual(val.z, 6.0, places=5)
self.assertAlmostEqual(val.w, 3.4, places=5)
def get_sky_spectrum(self, direction):
d = direction
if d.y < 0.0:
return self._col_mgr.black()
if d.y < 0.001:
d = Vector3(d.x, 0.001, d.z)
d.normalize()
theta = acos(d.y)
phi = atan2(d.x, d.z)
if phi < 0.0:
phi = phi + 2 * pi
gamma = self._angle_beetween(theta, phi, self._theta_sun,
self._phi_sun)
x = self._perez_function(self._perez_x, theta, gamma, self._zenith_x)
y = self._perez_function(self._perez_y, theta, gamma, self._zenith_y)
Y = self._perez_function(self._perez_Y, theta, gamma, self._zenith_Y)
spec = self._col_mgr.chromacity_to_spectrum(x, y)
spec = spec * (Y / self._col_mgr.Y(spec))
return spec
def test_rgb_to_spec2(self):
code = """
spec1 = rgb_to_spectrum(vec)
"""
vec = Vector3(0.2, 0.3, 0.2)
col_mgr = ColorManager(spectral=True)
rgb = col_mgr.black()
props = {'spec1': rgb, 'vec': vec}
bs = BasicShader(code, props, col_mgr=col_mgr)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('spec1')
val2 = col_mgr.create_spectrum((0.2, 0.3, 0.2), illum=False)
for i in range(len(val2.samples)):
self.assertAlmostEqual(val.samples[i], val2.samples[i], places=5)
def test_atanr2(self):
code = """
ret = atanr2(1.4, 4.4)
ret2 = atanr2((1.1, 1.25), (2.1, 3.1))
"""
props = {
'ret': 1.1,
'ret2': Vector2(2.2, 4),
'ret3': Vector3(5, 6, 7),
'ret4': Vector4(11, 1, 1, 1)
}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('ret')
self.assertAlmostEqual(val, math.atan2(1.4, 1.0 / 4.4), places=3)
val = bs.shader.get_value('ret2')
self.assertAlmostEqual(val.x, math.atan2(1.1, 1.0 / 2.1), places=3)
self.assertAlmostEqual(val.y, math.atan2(1.25, 1.0 / 3.1), places=3)
def test_sampled_spec_to_rgb(self):
code = """
vec = spectrum_to_rgb(spec1)
"""
col_mgr = ColorManager(spectral=True)
rgb = col_mgr.create_spectrum((0.2, 0.3, 0.2))
vec = Vector3(0.0, 0.0, 0.0)
props = {'spec1': rgb, 'vec': vec}
bs = BasicShader(code, props, col_mgr=col_mgr)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('vec')
val2 = col_mgr.to_RGB(rgb)
self.assertAlmostEqual(val.x, val2.r, places=5)
self.assertAlmostEqual(val.y, val2.g, places=5)
self.assertAlmostEqual(val.z, val2.b, places=5)
def test_lum1(self):
code = """
ret1 = luminance(v1)
ret2 = luminance(v2)
"""
v1 = Vector3(0.2, 0.3, 0.4)
v2 = Vector4(0.4, 0.1, 0.2, 0.5)
props = {'v1': v1, 'v2': v2, 'ret1': 0.0, 'ret2': 0.0}
bs = BasicShader(code, props)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
lum1 = v1.x * 0.2126 + v1.y * 0.7152 + v1.z * 0.0722
lum2 = bs.shader.get_value('ret1')
lum3 = v2.x * 0.2126 + v2.y * 0.7152 + v2.z * 0.0722
lum4 = bs.shader.get_value('ret2')
self.assertAlmostEqual(lum1, lum2, places=5)
self.assertAlmostEqual(lum3, lum4, places=5)
def test_rgb_to_spec(self):
code = """
spec1 = rgb_to_spectrum(vec)
"""
rgb = RGBSpectrum(0.0, 0.0, 0.0)
vec = Vector3(0.2, 0.3, 0.2)
props = {'spec1': rgb, 'vec': vec}
col_mgr = ColorManager(spectral=False)
bs = BasicShader(code, props, col_mgr=col_mgr)
runtime = Runtime()
bs.prepare([runtime])
#print (bs.shader._code)
bs.execute()
val = bs.shader.get_value('spec1')
self.assertAlmostEqual(vec.x, val.r, places=5)
self.assertAlmostEqual(vec.y, val.g, places=5)
self.assertAlmostEqual(vec.z, val.b, places=5)
def fetch_triangle(mesh, index):
v0, v1, v2 = mesh.get_indices(index)
p0 = mesh.get_point(v0)
p0 = Vector3(p0[0], p0[1], p0[2])
p1 = mesh.get_point(v1)
p1 = Vector3(p1[0], p1[1], p1[2])
p2 = mesh.get_point(v2)
p2 = Vector3(p2[0], p2[1], p2[2])
if mesh.has_normals():
n0 = mesh.get_normal(v0)
n0 = Vector3(n0[0], n0[1], n0[2])
n1 = mesh.get_normal(v1)
n1 = Vector3(n1[0], n1[1], n1[2])
n2 = mesh.get_normal(v2)
n2 = Vector3(n2[0], n2[1], n2[2])
else:
n0 = n1 = n2 = None
if mesh.has_uv():
uv0 = mesh.get_uv(v0)
uv1 = mesh.get_uv(v1)
uv2 = mesh.get_uv(v2)
tu0 = uv0[0]
tv0 = uv0[1]
tu1 = uv1[0]
tv1 = uv1[1]
tu2 = uv2[0]
tv2 = uv2[1]
else:
tu0 = tv0 = tu1 = tv1 = tu2 = tv2 = None
tri = Triangle(p0,
p1,
p2,
mesh.material_idx,
n0=n0,
n1=n1,
n2=n2,
tu0=tu0,
tv0=tv0,
tu1=tu1,
tv1=tv1,
tu2=tu2,
tv2=tv2)
#tri = Triangle(p0, p1, p2, mesh.material_idx, n0=n0, n1=n1, n2=n2)
return tri
def test_isect1(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([runtime], "ray_rectangle_intersection")
assembler = create_assembler()
mc = assembler.assemble(self.asm_code())
ds = runtime.load("test", mc)
self.intersect(ray, rectangle, runtime, ds)
def create_triangle(v0,
v1,
v2,
n0=None,
n1=None,
n2=None,
uv0=None,
uv1=None,
uv2=None):
p0 = Vector3(v0[0], v0[1], v0[2])
p1 = Vector3(v1[0], v1[1], v1[2])
p2 = Vector3(v2[0], v2[1], v2[2])
if n0 is not None:
n0 = Vector3(n0[0], n0[1], n0[2])
n1 = Vector3(n1[0], n1[1], n1[2])
n2 = Vector3(n2[0], n2[1], n2[2])
if uv0 is not None:
tu0, tv0 = uv0
tu1, tv1 = uv1
tu2, tv2 = uv2
else:
tu0 = tv0 = tu1 = tv1 = tu2 = tv2 = None
t = Triangle(p0,
p1,
p2,
n0=n0,
n1=n1,
n2=n2,
tu0=tu0,
tv0=tv0,
tu1=tu1,
tv1=tv1,
tu2=tu2,
tv2=tv2)
return t
from renmas3.base import Vector3
from renmas3.shapes import ShapeManager, Triangle
v0 = Vector3(2.2, 4.4, 6.6)
v1 = Vector3(1.1, 1.1, 1.1)
v2 = Vector3(5.1, -1.1, 5.1)
t = Triangle(v0, v1, v2)
t2 = Triangle(v0, v1, v2)
mgr = ShapeManager()
mgr.add('t1', t)
mgr.add('t2', t2)
print(mgr.address_info(t))
for s in mgr:
print (s)
