VoxelEngine/Client/Client.py

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])