from OpenGL.GL import *
import numpy as np
from OpenGL.GL.ARB.vertex_array_object import glDeleteVertexArrays
from OpenGL.GL.framebufferobjects import glBindRenderbuffer
from OpenGL.GLUT import *
import OpenGL.GLUT.freeglut
from OpenGL.GLU import *
from OpenGL.GL import *
from ctypes import sizeof, c_float, c_void_p, c_uint
from Lights.Spotlight.Spotlight import Spotlight
from WorldProvider.WorldProvider import WorldProvider
from MatrixStuff.Transformations import perspectiveMatrix, lookAt, translate, rotate
from Objects.Cube.Cube import Cube
from Objects.Cuboid.Cuboid import Cuboid
from Objects.World import World
import json
import random
import time
from scipy.signal import convolve
MAX_DISTANCE = 200.0
FRICTION_COEFFICENT = 1
EPSILON = 0.00001
def value_to_color(v, min_value, max_value):
r = g = b = 0.0
scope = max_value - min_value
normalized = (v - min_value) / (max_value - min_value)
if 0.5 * scope + min_value != 0:
b = max(0, 1.0 - abs(2.0 * normalized))
g = max(0, 1.0 - abs(2.0 * normalized - 1.0))
r = max(0, 1.0 - abs(2.0 * normalized - 2.0))
l = np.sqrt((r * r + b * b + g * g))
r /= l
g /= l
b /= l
return r, g, b
class Client:
def __init__(self, test=False, pos=[0, 0, 0]):
self.state = 0
with open('./config.json', 'r') as f:
self.config = json.load(f)
glutInit(sys.argv)
self.width = 1920
self.height = 1080
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(self.width, self.height)
glutCreateWindow(b'Voxelengine')
with open('passthroughvertex.glsl', 'r') as f:
vertex_shader_string = f.read()
self.passthrough_vertex_shader_id = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(self.passthrough_vertex_shader_id, vertex_shader_string)
glCompileShader(self.passthrough_vertex_shader_id)
if glGetShaderiv(self.passthrough_vertex_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
raise RuntimeError(glGetShaderInfoLog(self.passthrough_vertex_shader_id))
with open('vertex.glsl', 'r') as f:
vertex_shader_string = f.read()
self.vertex_shader_id = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(self.vertex_shader_id, vertex_shader_string)
glCompileShader(self.vertex_shader_id)
if glGetShaderiv(self.vertex_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
raise RuntimeError(glGetShaderInfoLog(self.vertex_shader_id))
with open('fragment.glsl', 'r') as f:
fragment_shader_string = f.read()
self.fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(self.fragment_shader_id, fragment_shader_string)
glCompileShader(self.fragment_shader_id)
if glGetShaderiv(self.fragment_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
raise RuntimeError(glGetShaderInfoLog(self.fragment_shader_id))
Cube.initializeShader()
Cuboid.initializeShader()
self.geometry_shaders = {
Cube: Cube.GeometryShaderId,
Cuboid: Cuboid.GeometryShaderId
}
self.normal_program = {}
self.depth_program = {}
for key in self.geometry_shaders.keys():
self.normal_program[key] = glCreateProgram()
glAttachShader(self.normal_program[key], self.vertex_shader_id)
glAttachShader(self.normal_program[key], key.GeometryShaderId)
glAttachShader(self.normal_program[key], self.fragment_shader_id)
glLinkProgram(self.normal_program[key])
self.depth_program[self.normal_program[key]] = Spotlight.getDepthProgram(self.vertex_shader_id,
key.GeometryShaderId)
self.world_provider = WorldProvider(self.normal_program)
for x_pos in range(0, 100):
for y_pos in range(0, 100):
for z_pos in range(0, 1):
self.world_provider.world.put_object(x_pos, y_pos, z_pos, Cuboid().setColor(
random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0))
self.projMatrix = perspectiveMatrix(45.0, 400 / 400, 0.01, MAX_DISTANCE)
self.rx = self.cx = self.cy = 0
self.opening = 45
glutReshapeFunc(self.resize)
glutDisplayFunc(self.display)
glutKeyboardFunc(self.keyboardHandler)
glutSpecialFunc(self.funcKeydHandler)
self.pos = pos
self.time = time.time()
self.field = (100, 100, 1)
self.e_a = np.array([
# [0, 0, 0],
[1, 0, 0],
[1, 1, 0],
[0, 1, 0],
[-1, 1, 0],
[-1, 0, 0],
[-1, -1, 0],
[0, -1, 0],
[1, -1, 0],
])
self.relaxation_time = 0.55 # 0.55
self.w_a = [
4.0 / 9.0,
1.0 / 9.0,
1.0 / 36.0,
1.0 / 9.0,
1.0 / 36.0,
1.0 / 9.0,
1.0 / 36.0,
1.0 / 9.0,
1.0 / 36.0
]
self.n_a = np.zeros((len(self.e_a),) + self.field)
self.n_a_eq = np.zeros(self.n_a.shape)
self.n = np.zeros(self.field, np.int)
self.n[:, 50:, :] += 1
self.viscosity = np.reshape(self.n * 0.01, self.field + (1,))
self.gravity_applies = np.zeros(self.field)
# self.n /= np.sum(self.n)
self.n_a[0] = np.array(self.n)
self.u = np.zeros(self.field + (self.e_a.shape[1],))
self.f = np.zeros(self.field + (self.e_a.shape[1],))
self.true_pos = np.zeros(self.field + (self.e_a.shape[1],))
self.pos_indices = np.zeros(self.field + (self.e_a.shape[1],), dtype=np.int)
for x in range(self.field[0]):
for y in range(self.field[1]):
for z in range(self.field[2]):
self.pos_indices[x, y, z, :] = [x, y, z]
self.compressible = True
self.max_n = self.w_a[0]
self.test_pixel = [40, 50, 0]
if not test:
glutMainLoop()
else:
self.display()
self.resize(100, 100)
def display(self):
glClearColor(0, 0, 0, 0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
projMatrix = perspectiveMatrix(45, float(self.width) / float(self.height), 0.01, MAX_DISTANCE)
world: World = self.world_provider.world
lights = world.get_lights_to_render(self.pos, self.config['render_light_distance'])
for light in lights:
light.prepareForDepthMapping()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
light_mat = translate(light.pos[0], light.pos[1], light.pos[2]) * \
lookAt(0, 0, 0, -light.pos[0], -light.pos[1], -light.pos[2], 0, 1, 0) * \
perspectiveMatrix(90, float(light.map_size) / float(light.map_size), 0.01, MAX_DISTANCE)
for obj_type, program_id in self.depth_program.items():
glUseProgram(program_id)
widthid = glGetUniformLocation(program_id, 'width')
heightid = glGetUniformLocation(program_id, 'height')
nearid = glGetUniformLocation(program_id, 'near')
farid = glGetUniformLocation(program_id, 'far')
glUniform1f(nearid, 0.01)
glUniform1f(farid, 100)
glUniform1f(widthid, light.map_size)
glUniform1f(heightid, light.map_size)
world.render(light_mat, rotate(0, 0, 0), self.depth_program)
glFlush()
light.finishDepthMapping()
glClearColor(0, 0, 0, 0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glClearColor(0, 0, 0, 0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
for obj_type, program_id in self.normal_program.items():
glUseProgram(program_id)
widthid = glGetUniformLocation(program_id, 'width')
heightid = glGetUniformLocation(program_id, 'height')
nearid = glGetUniformLocation(program_id, 'near')
farid = glGetUniformLocation(program_id, 'far')
glUniform1f(nearid, 0.01)
glUniform1f(farid, 100)
glUniform1f(widthid, self.width)
glUniform1f(heightid, self.height)
world.render(translate(self.pos[0], self.pos[1], self.pos[2]) * lookAt(0, 0, 0, 0, 0, -self.pos[2], 0, 1,
0) * projMatrix, rotate(0, 0, 0))
glFlush()
glutSwapBuffers()
min_value = 0
max_value_n = np.max(self.n)
# max_value_n = 1.0
vel = np.sqrt(np.sum(np.square(self.u), axis=3)) * self.n
max_value_vel = np.max(vel)
# max_value_vel = np.sqrt(3)
print('round')
print('sum n: %f' % np.sum(self.n))
print('max n: %f' % np.max(self.n))
print('min n: %f' % np.min(self.n))
print('sum vel: %f' % np.sum(vel))
print('max vel: %f' % np.max(vel))
print('min vel: %f' % np.min(vel))
for x_pos in range(0, 100):
for y_pos in range(0, 100):
for z_pos in range(0, 1):
if self.state == 2:
r, g, b = value_to_color(int(self.gravity_applies[x_pos, y_pos, z_pos]), 0, 1)
if self.state == 1:
r, g, b = value_to_color(vel[x_pos, y_pos, z_pos], min_value, max_value_vel)
if self.state == 0:
r, g, b = value_to_color(self.n[x_pos, y_pos, z_pos], min_value, max_value_n)
self.world_provider.world.set_color(x_pos, y_pos, z_pos, r, g, b)
self.world_provider.world.set_color(int(round(self.test_pixel[0])),
int(round(self.test_pixel[1])),
int(round(self.test_pixel[2])), 1.0, 1.0, 1.0)
new_f = np.zeros(self.f.shape)
# viscosity
neighbours_filter = np.zeros((3, 3, 3), np.int) + 1
neighbours = convolve(np.pad(self.n, 1, constant_values=0), neighbours_filter, mode='valid') * self.n
neighbours = np.reshape(neighbours, self.field + (1,))
forces_to_share_per_neighbor = self.f * self.viscosity
length = np.sqrt(np.sum(np.square(forces_to_share_per_neighbor), axis=3, keepdims=True))
direction = forces_to_share_per_neighbor / length
direction[(length == 0)[:, :, :, 0]] = 0
############################## experimental
for a in range(len(self.e_a)):
unit = self.e_a[a] / np.sqrt(np.sum(np.square(self.e_a[a])))
scalar = np.sum(direction * unit, axis=3, keepdims=True)
altered_direction = direction + scalar * unit
altered_length = np.sqrt(np.sum(np.square(altered_direction), axis=3, keepdims=True))
altered_direction = altered_direction / altered_length
altered_direction[(altered_length == 0)[:, :, :, 0]] = 0
f_2_add = length * altered_direction
new_f[max(0, self.e_a[a][0]):min(new_f.shape[0], new_f.shape[0] + self.e_a[a][0]),
max(0, self.e_a[a][1]):min(new_f.shape[1], new_f.shape[1] + self.e_a[a][1]),
max(0, self.e_a[a][2]):min(new_f.shape[2], new_f.shape[2] + self.e_a[a][2])] += f_2_add[
max(0, -self.e_a[a][0]):min(
new_f.shape[0],
new_f.shape[0] -
self.e_a[a][0]),
max(0, -self.e_a[a][1]):min(
new_f.shape[1],
new_f.shape[1] -
self.e_a[a][1]),
max(0, -self.e_a[a][2]):min(
new_f.shape[2],
new_f.shape[2] -
self.e_a[a][2])]
new_f += self.f - forces_to_share_per_neighbor * neighbours
#########################################
new_f += self.f
# TODO movement generating things
# gravity
new_f[:, :, :, 1] -= 1.0 * self.n
# clean up
new_f[self.n == 0] = 0
self.f = new_f
# collision and movement
collision = True
iterations = 0
while collision:
f_length = np.sqrt(np.sum(np.square(self.f), axis=3, keepdims=True))
f_direction = self.f / f_length
f_direction[f_length[:, :, :, 0] == 0] = 0
velocity = f_direction * np.sqrt(f_length) / np.reshape(self.n, self.field + (1,)) # TODO replace self.n by mass
velocity[self.n == 0] = 0
timestep = min(1, 0.5 / np.max(np.sqrt(np.sum(np.square(velocity), axis=3))))
if iterations > 20:
print('Takes too long!')
timestep /= 10
new_pos = self.true_pos + velocity * timestep
new_pos_round = np.round(new_pos)
moved = np.logical_or.reduce(new_pos_round != [0, 0, 0], axis=3)
pos_change_targets = new_pos_round[moved] + self.pos_indices[moved]
# handle bordercases
bordercase = np.array(moved)
bordercase[moved] = np.logical_or(
np.logical_or(np.logical_or(0 > pos_change_targets[:, 0], pos_change_targets[:, 0] >= self.field[0]),
np.logical_or(0 > pos_change_targets[:, 1], pos_change_targets[:, 1] >= self.field[1])),
np.logical_or(0 > pos_change_targets[:, 2], pos_change_targets[:, 2] >= self.field[2]))
self.f[bordercase] *= -1
velocity[bordercase] *= -1
# recalculate targets
new_pos = self.true_pos + velocity * timestep
new_pos_round = np.round(new_pos)
new_pos_target = new_pos_round + self.pos_indices
contenders = np.zeros(self.field)
starts = self.pos_indices[self.n != 0]
targets = new_pos_target[self.n != 0].astype(np.int)
speeds = velocity[self.n != 0]
forces = new_f[self.n != 0]
max_speeds = np.zeros(self.field)
fast_pos = {}
is_stayer = []
for index in range(len(targets)):
target = targets[index]
speed = np.sqrt(np.sum(np.square(speeds[index])))
contenders[target[0], target[1], target[2]] += 1
# new max speed and we do not update stayers
if speed > max_speeds[target[0], target[1], target[2]] and tuple(target) not in is_stayer:
max_speeds[target[0], target[1], target[2]] = speed
fast_pos[tuple(target)] = index
# atoms that are already there are there (and stay there) are the fastest
start = starts[index]
if np.all(start == target):
fast_pos[tuple(target)] = index
is_stayer.append(tuple(target))
collision = np.max(contenders) > 1
# we only need collision if there is one
if collision:
# go through the movers again
for index in range(len(targets)):
target = targets[index]
# collision here?
if contenders[target[0], target[1], target[2]] > 1:
# the fastest one does not need to do anything
if index != fast_pos[tuple(target)]:
force = forces[index]
fastest = fast_pos[tuple(target)]
# TODO use relative weight?
forces[fastest] += 0.5*force
forces[index] *= 0.5
new_f[self.n != 0] = forces
self.f = new_f
iterations += 1
# final calculation
f_length = np.sqrt(np.sum(np.square(self.f), axis=3, keepdims=True))
f_direction = self.f / f_length
f_direction[f_length[:, :, :, 0] == 0] = 0
velocity = f_direction * np.sqrt(f_length) / np.reshape(self.n, self.field + (1,)) # TODO replace self.n by mass
velocity[self.n == 0] = 0
#timestep = min(1, 0.5 / np.max(np.sqrt(np.sum(np.square(velocity), axis=3))))
new_pos = self.true_pos + velocity * timestep
new_pos_round = np.round(new_pos)
moved = np.logical_or.reduce(new_pos_round[:, :, :] != [0, 0, 0], axis=3)
not_moved = np.logical_and.reduce(new_pos_round[:, :, :] == [0, 0, 0], axis=3)
pos_change_targets = (new_pos_round[moved] + self.pos_indices[moved]).astype(np.int)
movers = self.pos_indices[moved]
print('timestep: %f' % timestep)
update_n = np.zeros(self.n.shape, np.int)
update_f = np.zeros(self.f.shape)
update_u = np.zeros(self.u.shape)
update_true_pos = np.zeros(self.true_pos.shape)
update_n[not_moved] = self.n[not_moved]
update_f[not_moved, :] = self.f[not_moved, :]
update_u[not_moved, :] = velocity[not_moved, :]
update_true_pos[not_moved, :] = new_pos[not_moved, :]
for indice in range(len(movers)):
mover = movers[indice]
target = pos_change_targets[indice]
update_n[target[0], target[1], target[2]] = self.n[mover[0], mover[1], mover[2]]
update_f[target[0], target[1], target[2], :] = self.f[mover[0], mover[1], mover[2], :]
update_u[target[0], target[1], target[2], :] = velocity[mover[0], mover[1], mover[2], :]
update_true_pos[target[0], target[1], target[2], :] = new_pos[mover[0], mover[1], mover[2], :] - new_pos_round[mover[0], mover[1], mover[2], :]
self.n = update_n
self.f = update_f
self.u = update_u
self.true_pos = update_true_pos
print(1.0 / (time.time() - self.time))
self.time = time.time()
glutPostRedisplay()
def resize(self, w, h):
w = max(w, 1)
h = max(h, 1)
glViewport(0, 0, w, h)
self.projMatrix = perspectiveMatrix(45.0, float(w) / float(h), 0.01, MAX_DISTANCE)
self.width = w
self.height = h
def keyboardHandler(self, key: int, x: int, y: int):
if key == b'\x1b':
exit()
if key == b'+':
self.rx += 0.25
if key == b'-':
self.rx -= 0.25
if key == b'w':
self.cy += 0.25
if key == b's':
self.cy -= 0.25
if key == b'a':
self.cx -= 0.25
if key == b'd':
self.cx += 0.25
if key == b'q':
self.opening -= 0.25
if key == b'e':
self.opening += 0.25
if key == b'+':
self.state = (self.state + 1) % 3
if key == b'r':
print(self.cx, self.cy, self.opening)
# glutPostRedisplay()
# print(key,x,y)
def funcKeydHandler(self, key: int, x: int, y: int):
if key == 11:
glutFullScreenToggle()
# print(key)
if __name__ == '__main__':
client = Client(pos=[-50, -50, -200])