def _create_grid(self, runtimes, intersector, visibility=False):
# we must alocate memory for 3d grid and array
cells = self.cells
nx = self.nx
ny = self.ny
nz = self.nz
num_cells = int(nx * ny * nz)
if visibility:
self.asm_cells_b = x86.MemData(num_cells * 4)
self.asm_cells_b.fill()
self.lin_arrays_b = {}
else:
self.asm_cells = x86.MemData(num_cells * 4)
self.asm_cells.fill()
self.lin_arrays = {}
for r in runtimes:
if visibility:
self.lin_arrays_b[r] = x86.MemData(
self.num_arrays * 4 + self.num_objects * 8 +
4) #we start of index[1] that why extra four bytes
x86.SetUInt32(self.lin_arrays_b[r].ptr(), 0, 0)
else:
self.lin_arrays_b = {}
self.lin_arrays[r] = x86.MemData(
self.num_arrays * 4 + self.num_objects * 8 +
4) #we start of index[1] that why extra four bytes
x86.SetUInt32(self.lin_arrays[r].ptr(), 0, 0)
offset = 4 # offset is in bytes
if visibility:
addr_cells = self.asm_cells_b.ptr()
else:
addr_cells = self.asm_cells.ptr()
for k in range(nz):
for j in range(ny):
for i in range(nx):
idx = i + nx * j + nx * ny * k
cell = cells[idx]
if len(cell) == 0:
pass
else:
adr = addr_cells + idx * 4
x86.SetUInt32(adr, offset, 0)
for r in runtimes:
if visibility:
addr_arr = self.lin_arrays_b[r].ptr()
else:
addr_arr = self.lin_arrays[r].ptr()
adr = addr_arr + offset
num = len(cell)
x86.SetUInt32(adr, num, 0)
x86.SetUInt32(
adr + 4,
self._get_ptrs_obj_func(
cell, r, intersector, visibility), 0)
offset = offset + len(cell) * 8 + 4
def _create_grid(self, cells):
# we must alocate memory for 3d grid and array
nx = self.nx
ny = self.ny
nz = self.nz
num_cells = int(nx * ny * nz)
self.asm_cells = x86.MemData(num_cells * 4)
self.asm_cells.fill()
self.lin_array = x86.MemData(
self.num_arrays * 4 + self.num_objects * 4 +
4) #we start of index[1] that why extra four bytes
x86.SetUInt32(self.lin_array.ptr(), 0, 0)
offset = 4 # offset is in bytes
addr_cells = self.asm_cells.ptr()
addr_arr = self.lin_array.ptr()
for k in range(nz):
for j in range(ny):
for i in range(nx):
idx = i + nx * j + nx * ny * k
cell = cells[idx]
if len(cell) == 0:
pass
else:
adr = addr_cells + idx * 4
x86.SetUInt32(adr, offset, 0)
adr = addr_arr + offset
num = len(cell)
x86.SetUInt32(adr, num, 0)
offset += 4
x86.SetUInt32(adr + 4, tuple(cell), 0)
offset = offset + len(cell) * 4
def add_vertex(self, x, y, z, nx=None, ny=None, nz=None, u=None, v=None):
if self.address is None:
self.address = x86.MemData(self.vertex_size)
self.reserve += 1
elif self.reserve == self.size:
if self.size > 0 and self.size <= 100:
self.reserve += 1
elif self.size > 100 and self.size <= 10000:
self.reserve += 100
elif self.size > 10000 and self.size <= 1000000:
self.reserve += 10000
else:
self.reserve += 100000
temp = x86.MemData(self.vertex_size*self.reserve)
util.memcpy(temp.ptr(), self.address.ptr(), self.size*self.vertex_size)
self.address = temp
offset = self.vertex_size * self.size
x86.SetFloat(self.address.ptr()+offset, (x, y, z, 0.0), 0)
if nx is not None:
noffset = offset + self.normal_offset
x86.SetFloat(self.address.ptr()+noffset, (nx, ny, nz, 0.0), 0)
if u is not None:
noffset = offset + self.uv_offset
x86.SetFloat(self.address.ptr()+noffset, (u, v, 0.0, 0.0), 0)
self.size += 1
def add_triangle(self, v0, v1, v2, material, nx=None, ny=None, nz=None):
if self.address is None:
self.address = x86.MemData(self.tri_size)
self.reserve += 1
elif self.reserve == self.size:
if self.size > 0 and self.size <= 100:
self.reserve += 1
elif self.size > 100 and self.size <= 10000:
self.reserve += 100
elif self.size > 10000 and self.size <= 1000000:
self.reserve += 10000
else:
self.reserve += 100000
temp = x86.MemData(self.tri_size*self.reserve)
util.memcpy(temp.ptr(), self.address.ptr(), self.size*self.tri_size)
self.address = temp
offset = self.tri_size * self.size
x86.SetInt32(self.address.ptr()+offset, (v0, v1, v2, material), 0)
if self.has_normal and nx is not None:
offset = offset + 16 # offset to normal
x86.SetFloat(self.address.ptr()+offset, (nx, ny, nz, 0.0), 0)
self.size += 1
def __init__(self, vertex_type=None, reserve=0):
#size of vertex dependes on type
self.size = 0
self.vertex_type = vertex_type
self.reserve = reserve
if vertex_type is None:
self.vertex_size = 16 #store x, y, z, xx(aligment)
else:
if vertex_type.has_normal() and vertex_type.has_uv():
self.normal_offset = 16
self.uv_offset = 32
self.vertex_size = 48 # store x,y,z,xx for vertex, x,y,z,xx for normal, u,v,xx,xx for texture
elif vertex_type.has_normal():
self.normal_offset = 16
self.vertex_size = 32 # store x,y,z,xx for vertex and than x,y,z,xx for normal
pass
elif vertex_type.has_uv():
self.uv_offset = 16
self.vertex_size = 32 # store x,y,z,xx for vertex and u,v, xx,xx for texture coordinates
else:
self.vertex_size = 16
if self.reserve > 0:
self.address = x86.MemData(self.reserve*self.vertex_size)
else:
self.address = None
def __init__(self, item_size, reserve=0):
self._size = 0
self._reserve = reserve
self._item_size = item_size
if reserve < 1:
self._reserve = 1
self._address = x86.MemData(self._reserve * self._item_size)
def __init__(self, width, height, pitch):
"""
Create image with specified width and height.
Also pitch is required that represent number of bytes in raw.
"""
self.pitch = pitch
self.width = width
self.height = height
self._pixels = x86.MemData(height * pitch)
def __init__(self, width, height, pitch):
## @brief pitch of the image(number of bytes in row)
self.pitch = pitch
## @brief width of the image
self.width = width
## @brief height of the image
self.height = height
self._pixels = x86.MemData(height * pitch)
def __init__(self, item_size, reserve=0):
self._reserve = reserve
self._item_size = item_size
self._size = 0
if self._reserve > 0:
self._address = x86.MemData(self._reserve * self._item_size)
else:
self._address = None
def _resize(self):
if self._size >= 0 and self._size <= 100:
self._reserve += 1
elif self._size > 100 and self._size <= 10000:
self._reserve += 100
elif self._size > 10000 and self._size <= 1000000:
self._reserve += 10000
else:
self._reserve += 100000
temp = x86.MemData(self._item_size * self._reserve)
memcpy(temp.ptr(), self._address.ptr(), self._size * self._item_size)
self._address = temp
def add_default_instances(self, n): #TODO improve performnase of this!
for k in range(n):
if self.address is None:
self.address = x86.MemData(self.sizeof)
self.reserve += 1
elif self.reserve == self.size:
if self.size > 0 and self.size <= 100:
self.reserve += 1
elif self.size > 100 and self.size <= 10000:
self.reserve += 100
elif self.size > 10000 and self.size <= 1000000:
self.reserve += 10000
else:
self.reserve += 100000
temp = x86.MemData(self.sizeof * self.reserve)
memcpy(temp.ptr(), self.address.ptr(), self.size * self.sizeof)
self.address = temp
offset = self.sizeof * self.size
x86.SetData(self.address.ptr() + offset, self.bytes)
self.size += 1
def add_instance(self, instance):
if self.address is None:
self.address = x86.MemData(self.sizeof)
self.reserve += 1
elif self.reserve == self.size:
if self.size > 0 and self.size <= 100:
self.reserve += 1
elif self.size > 100 and self.size <= 10000:
self.reserve += 100
elif self.size > 10000 and self.size <= 1000000:
self.reserve += 10000
else:
self.reserve += 100000
temp = x86.MemData(self.sizeof * self.reserve)
memcpy(temp.ptr(), self.address.ptr(), self.size * self.sizeof)
self.address = temp
offset = self.sizeof * self.size
x86.SetData(self.address.ptr() + offset, self.bytes)
for key, value in instance.items():
self._set_member(key, value, self.size)
self.size += 1
def __init__(self, has_normal=True, reserve=0):
# v0, v1, v2, material, normal
self.size = 0
self.reserve = reserve
self.has_normal = has_normal
if has_normal:
self.tri_size = 32
else:
self.tri_size = 16
if self.reserve > 0:
self.address = x86.MemData(self.reserve*self.tri_size)
else:
self.address = None
def __init__(self, struct, reserve=0):
self.size = 0
self.struct = struct
self.sizeof = struct.sizeof()
self.members = {}
self.members2 = {}
self.reserve = reserve
self.bytes = array.array("B", B'\x00' * struct.sizeof())
for key, value in struct.members.items():
name = key
data_type, value, is_array, arr_length, offset = value
self._register_member(name, value, data_type, offset, is_array, arr_length)
self.bytes = bytes(self.bytes)
if self.reserve > 0:
self.address = x86.MemData(self.reserve*self.sizeof)
else:
self.address = None
def append(self, value):
if self._reserve == self._size:
if self._size > 0 and self._size <= 100:
self._reserve += 1
elif self._size > 100 and self._size <= 10000:
self._reserve += 100
elif self._size > 10000 and self._size <= 1000000:
self._reserve += 10000
else:
self._reserve += 100000
temp = x86.MemData(self._item_size * self._reserve)
memcpy(temp.ptr(), self._address.ptr(),
self._size * self._item_size)
self._address = temp
offset = self._item_size * self._size
addr = self._address.ptr() + offset
self._set_item(addr, value)
self._size += 1
def __init__(self, width, height):
n = width * height * 4
self.pixels = x86.MemData(n)
self.width = width
self.height = height
self.pitch = width * 4
def setup(self, mesh):
self.mesh = mesh
p0 = Vector3(9999999.0, 9999999.0, 9999999.0)
p1 = Vector3(-9999999.0, -9999999.0, -9999999.0)
bb_min = BBox(p0, p1, None)
ntriangles = mesh.ntriangles() #get number of triangles
self.bbox = mesh.bbox() #get bounding box around mesh
bb_min = self.bbox
num_shapes = ntriangles
wx = bb_min.x1 - bb_min.x0
wy = bb_min.y1 - bb_min.y0
wz = bb_min.z1 - bb_min.z0
multiplier = 1.3 # about 8 times more cells than objects ako stavimo faktor 2 TODO test this!
s = math.pow(wx * wy * wz / float(num_shapes), 0.333333)
nx = int(multiplier * wx / s + 1)
ny = int(multiplier * wy / s + 1)
nz = int(multiplier * wz / s + 1)
self.nx = nx
self.ny = ny
self.nz = nz
num_cells = int(nx * ny * nz)
print("wx=", wx, " wy=", wy, " wz=", wz)
print("nx=", nx, " ny=", ny, " nz=", nz)
# every cell have referencs to objects that are in that cell
self.cells = [] # we need to initialize empty lists
for c in range(num_cells):
self.cells.append([])
max_len = 0
num_arrays = 0
num_objects = 0
for idx_triangle in range(ntriangles):
bbox = mesh.bbox_tri(idx_triangle)
ixmin = int(
clamp((bbox.x0 - bb_min.x0) * nx / (bb_min.x1 - bb_min.x0), 0,
nx - 1))
iymin = int(
clamp((bbox.y0 - bb_min.y0) * ny / (bb_min.y1 - bb_min.y0), 0,
ny - 1))
izmin = int(
clamp((bbox.z0 - bb_min.z0) * nz / (bb_min.z1 - bb_min.z0), 0,
nz - 1))
ixmax = int(
clamp((bbox.x1 - bb_min.x0) * nx / (bb_min.x1 - bb_min.x0), 0,
nx - 1))
iymax = int(
clamp((bbox.y1 - bb_min.y0) * ny / (bb_min.y1 - bb_min.y0), 0,
ny - 1))
izmax = int(
clamp((bbox.z1 - bb_min.z0) * nz / (bb_min.z1 - bb_min.z0), 0,
nz - 1))
#print("x = ", ixmin, ixmax)
#print("y = ", iymin, iymax)
#print("z = ", izmin, izmax)
for k in range(izmin, izmax + 1):
for j in range(iymin, iymax + 1):
for i in range(ixmin, ixmax + 1):
idx = i + nx * j + nx * ny * k
self.cells[idx].append(idx_triangle)
duzina = len(self.cells[idx])
num_objects += 1
if duzina == 1: num_arrays += 1
if duzina > max_len: max_len = duzina
nx_1 = float(self.nx - 1)
ny_1 = float(self.ny - 1)
nz_1 = float(self.nz - 1)
self.n_1 = Vector3(nx_1, ny_1, nz_1)
ovx = 1.0 / self.nx
ovy = 1.0 / self.ny
ovz = 1.0 / self.nz
self.one_overn = Vector3(ovx, ovy, ovz)
nboxx = float(self.nx / (self.bbox.x1 - self.bbox.x0))
nboxy = float(self.ny / (self.bbox.y1 - self.bbox.y0))
nboxz = float(self.nz / (self.bbox.z1 - self.bbox.z0))
self.nbox_width = Vector3(nboxx, nboxy, nboxz)
# we must alocate memory 3d grid and arrays
self.asm_cells = x86.MemData(num_cells * 4)
self.lin_array = x86.MemData(
num_arrays * 4 + num_objects * 4 +
4) #we start of index[1] that why extra four bytes
x86.SetUInt32(self.lin_array.ptr(), 0, 0)
offset = 4 # offset is in bytes
for k in range(nz):
for j in range(ny):
for i in range(nx):
idx = i + nx * j + nx * ny * k
cell = self.cells[idx]
if len(cell) == 0:
adr = self.asm_cells.ptr()
adr = adr + idx * 4
x86.SetUInt32(adr, 0, 0)
else:
adr = self.asm_cells.ptr()
adr = adr + idx * 4
x86.SetUInt32(adr, offset, 0)
adr = self.lin_array.ptr()
adr += offset
num = len(cell)
x86.SetUInt32(adr, num, 0)
offset += 4
x86.SetUInt32(adr + 4, tuple(cell), 0)
offset = offset + len(cell) * 4
print("Najduzi niz je", duzina)
return None
def __init__(self, width, height):
self.width = width
self.height = height
self.buffer = x86.MemData(width * height * 4)
def setup(self, shapes, ren=None):
p0 = Vector3(9999999.0, 9999999.0, 9999999.0)
p1 = Vector3(-9999999.0, -9999999.0, -9999999.0)
bb_min = BBox(p0, p1, None)
for shape in shapes:
bbox = shape.bbox()
if bbox.x0 < bb_min.x0: bb_min.x0 = bbox.x0
if bbox.y0 < bb_min.y0: bb_min.y0 = bbox.y0
if bbox.z0 < bb_min.z0: bb_min.z0 = bbox.z0
if bbox.x1 > bb_min.x1: bb_min.x1 = bbox.x1
if bbox.y1 > bb_min.y1: bb_min.y1 = bbox.y1
if bbox.z1 > bb_min.z1: bb_min.z1 = bbox.z1
self.bbox = bb_min
num_shapes = len(shapes) #FIXME when we incoorporate mesh
wx = bb_min.x1 - bb_min.x0
wy = bb_min.y1 - bb_min.y0
wz = bb_min.z1 - bb_min.z0
multiplier = 1.3 # about 8 times more cells than objects TODO test this!
s = math.pow(wx * wy * wz / float(num_shapes), 0.333333)
nx = int(multiplier * wx / s + 1)
ny = int(multiplier * wy / s + 1)
nz = int(multiplier * wz / s + 1)
self.nx = nx
self.ny = ny
self.nz = nz
num_cells = int(nx * ny * nz)
print("wx=", wx, " wy=", wy, " wz=", wz)
print("nx=", nx, " ny=", ny, " nz=", nz)
# every cell have referencs to objects that are in that cell
self.cells = [] # we need to initialize list
for c in range(num_cells):
self.cells.append([])
max_len = 0
num_arrays = 0
num_objects = 0
for shape in shapes:
bbox = shape.bbox()
ixmin = int(
clamp((bbox.x0 - bb_min.x0) * nx / (bb_min.x1 - bb_min.x0), 0,
nx - 1))
iymin = int(
clamp((bbox.y0 - bb_min.y0) * ny / (bb_min.y1 - bb_min.y0), 0,
ny - 1))
izmin = int(
clamp((bbox.z0 - bb_min.z0) * nz / (bb_min.z1 - bb_min.z0), 0,
nz - 1))
ixmax = int(
clamp((bbox.x1 - bb_min.x0) * nx / (bb_min.x1 - bb_min.x0), 0,
nx - 1))
iymax = int(
clamp((bbox.y1 - bb_min.y0) * ny / (bb_min.y1 - bb_min.y0), 0,
ny - 1))
izmax = int(
clamp((bbox.z1 - bb_min.z0) * nz / (bb_min.z1 - bb_min.z0), 0,
nz - 1))
#print("x = ", ixmin, ixmax)
#print("y = ", iymin, iymax)
#print("z = ", izmin, izmax)
for k in range(izmin, izmax + 1):
for j in range(iymin, iymax + 1):
for i in range(ixmin, ixmax + 1):
idx = i + nx * j + nx * ny * k
self.cells[idx].append(shape)
duzina = len(self.cells[idx])
num_objects += 1
if duzina == 1: num_arrays += 1
if duzina > max_len: max_len = duzina
nx_1 = float(self.nx - 1)
ny_1 = float(self.ny - 1)
nz_1 = float(self.nz - 1)
self.n_1 = Vector3(nx_1, ny_1, nz_1)
ovx = 1.0 / self.nx
ovy = 1.0 / self.ny
ovz = 1.0 / self.nz
self.one_overn = Vector3(ovx, ovy, ovz)
nboxx = float(self.nx / (self.bbox.x1 - self.bbox.x0))
nboxy = float(self.ny / (self.bbox.y1 - self.bbox.y0))
nboxz = float(self.nz / (self.bbox.z1 - self.bbox.z0))
self.nbox_width = Vector3(nboxx, nboxy, nboxz)
# we must alocate memory 3d grid and arrays
self.asm_cells = x86.MemData(num_cells * 4)
self.lin_array = x86.MemData(
num_arrays * 4 + num_objects * 8 +
4) #we start of index[1] that why extra four bytes
x86.SetUInt32(self.lin_array.ptr(), 0, 0)
offset = 4 # offset is in bytes
self.runtime = runtime = Runtime()
for k in range(nz):
for j in range(ny):
for i in range(nx):
idx = i + nx * j + nx * ny * k
cell = self.cells[idx]
if len(cell) == 0:
adr = self.asm_cells.ptr()
adr = adr + idx * 4
x86.SetUInt32(adr, 0, 0)
else:
adr = self.asm_cells.ptr()
adr = adr + idx * 4
x86.SetUInt32(adr, offset, 0)
adr = self.lin_array.ptr()
adr += offset
num = len(cell)
x86.SetUInt32(adr, num, 0)
offset += 4
if ren is None:
lst_address = renmas.interface.objfunc_array(
cell, runtime)
else:
lst_address = self.objfunc_array(
cell, runtime, ren)
n = len(lst_address)
x86.SetUInt32(adr + 4, lst_address, 0)
offset = offset + n * 4
#br = x86.GetUInt32(self.lin_array.ptr(), 0, 30)
#print("br", br)
#for k in range(nz):
# for j in range(ny):
# for i in range(nx):
# idx = i + nx * j + nx * ny * k
# adr = self.asm_cells.ptr()
# adr = adr + idx * 4
# br = x86.GetUInt32(adr, 0, 0)
# print(k, j, i, idx, br)
print("duzina", max_len)
print("num objects =", num_objects, " num arrays", num_arrays)
return None
def __init__(self, width, height, item_size):
self._width = width
self._height = height
self._item_size = item_size
self._address = x86.MemData(width * height * item_size)
def clear(self):
self._reserve = 1
self._address = x86.MemData(self._reserve * self._item_size)
self._size = 0
