VoxelEngine/main.py

import random
import sys

from WorldProvider.WorldProvider import WorldProvider

print('64' if sys.maxsize > 2 ** 32 else '32')

from Objects.Cube.Cube import Cube
from Objects.Cuboid.Cuboid import Cuboid
from Objects.Structure import Structure, CompoundStructure
from Lights.Spotlight.Spotlight import Spotlight
from Lights.LightingManager import *
import numpy as np
import time

name = b'ball_glut'

struct = None
cstruct = None
program_id = 0
program2_id = 0
program3_id = 0
start = time.time()
frames = 0
width = 1920
height = 1080
opening = 45
l = Spotlight()

wp = None


def main():
    lm = LightingManager()
    # lm.addRenderStep(0,0)
    # lm.addRenderStep(1,1)
    # lm.removeRenderStep(0,0)

    glutInit(sys.argv)
    w = width
    h = height
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
    glutInitWindowSize(w, h)
    glutCreateWindow(name)
    # glutEnterGameMode()

    print("Vendor:", glGetString(GL_VENDOR))
    print("Renderer:", glGetString(GL_RENDERER))
    print("Version:", glGetString(GL_VERSION))
    print("GLSL:", glGetString(GL_SHADING_LANGUAGE_VERSION))

    c = Cube()
    cuboid = Cuboid()

    glClearColor(0., 0., 0., 1.)
    # glShadeModel(GL_SMOOTH)
    # glDisable(GL_CULL_FACE)
    glEnable(GL_CULL_FACE)
    glCullFace(GL_BACK)
    glEnable(GL_TEXTURE_2D)
    glEnable(GL_DEPTH_TEST)

    # glEnable(GL_LIGHTING)
    '''lightZeroPosition = [10.,4.,10.,1.]
    lightZeroColor = [0.8,1.0,0.8,1.0] #green tinged
    glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition)
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor)
    glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1)
    glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05)
    glEnable(GL_LIGHT0)'''
    glutDisplayFunc(display)
    glutReshapeFunc(resize)
    glutKeyboardFunc(keyboardHandler)
    glutSpecialFunc(funcKeydHandler)
    '''glMatrixMode(GL_PROJECTION)
    gluPerspective(40.,1.,1.,40.)
    glMatrixMode(GL_MODELVIEW)'''
    # gluLookAt(0,0,10,
    #          0,0,0,
    #          0,1,0)
    # glPushMatrix()

    with open('passthroughvertex.glsl', 'r') as f:
        vertex_shader_string = f.read()
    passthrough_vertex_shader_id = glCreateShader(GL_VERTEX_SHADER)
    glShaderSource(passthrough_vertex_shader_id, vertex_shader_string)
    glCompileShader(passthrough_vertex_shader_id)
    if glGetShaderiv(passthrough_vertex_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
        raise RuntimeError(glGetShaderInfoLog(passthrough_vertex_shader_id))

    with open('vertex.glsl', 'r') as f:
        vertex_shader_string = f.read()
    vertex_shader_id = glCreateShader(GL_VERTEX_SHADER)
    glShaderSource(vertex_shader_id, vertex_shader_string)
    glCompileShader(vertex_shader_id)
    if glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
        raise RuntimeError(glGetShaderInfoLog(vertex_shader_id))

    with open('texturefragment.glsl', 'r') as f:
        fragment_shader_string = f.read()
    texturefragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER)
    glShaderSource(texturefragment_shader_id, fragment_shader_string)
    glCompileShader(texturefragment_shader_id)
    if glGetShaderiv(texturefragment_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
        raise RuntimeError(glGetShaderInfoLog(texturefragment_shader_id))

    with open('fragment.glsl', 'r') as f:
        fragment_shader_string = f.read()
    fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER)
    glShaderSource(fragment_shader_id, fragment_shader_string)
    glCompileShader(fragment_shader_id)
    if glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
        raise RuntimeError(glGetShaderInfoLog(fragment_shader_id))

    global program_id, program2_id, program3_id
    program_id = glCreateProgram()
    glAttachShader(program_id, vertex_shader_id)
    glAttachShader(program_id, Cuboid.GeometryShaderId)
    # glAttachShader(program_id, Cuboid.GeometryShaderId)
    glAttachShader(program_id, fragment_shader_id)
    # glAttachShader(program_id, l.FragmentShaderId)
    glLinkProgram(program_id)

    global struct, cstruct
    struct = Structure()
    struct.addShape(program_id, Cuboid().translate(translate(0, 0, 1)).setColor(1, 1, 0))
    # struct.addShape(program_id, Cube().translate(translate(1, 1, 0)).setColor(0, 0, 1))
    # struct.addShape(program_id, Cube().translate(translate(1, 0, 0)).setColor(0, 1, 0))
    # struct.addShape(program_id, Cube().translate(translate(1, -1, 0)).setColor(1, 0, 0))
    # struct.addShape(program_id, Cube().translate(translate(0, -1, 0)).setColor(0, 1, 0))
    # struct.addShape(program_id, Cube().translate(translate(-1, -1, 0)).setColor(0, 0, 1))
    # struct.addShape(program_id, Cube().translate(translate(-1, 0, 0)).setColor(0, 1, 1))
    # struct.addShape(program_id, Cube().translate(translate(-1, 1, 0)).setColor(1, 1, 1))
    # struct.addShape(program_id, Cube().translate(translate(0, 1, 0)).setColor(0, 0, 1))

    for x_pos in range(0, 10, 1):
        for y_pos in range(0, 10):
            z = random.random() * 2 - 1
            struct.addShape(program_id, Cuboid().translate(translate(x_pos, y_pos, z)).setColor(
                random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0).setSize(
                random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0
            ))

    global wp
    wp = WorldProvider({Cuboid: program_id})

    for x_pos in range(0, 10):
        for y_pos in range(0, 10):
            for z_pos in range(0, 10):
                wp.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).setSize(
                random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0
            ))

    # struct.clearVertexArrays()

    cstruct = CompoundStructure()
    cstruct.addStructure(struct)

    program3_id = l.getDepthProgram(vertex_shader_id, Cuboid.GeometryShaderId)

    program2_id = glCreateProgram()
    glAttachShader(program2_id, passthrough_vertex_shader_id)
    glAttachShader(program2_id, texturefragment_shader_id)
    glLinkProgram(program2_id)

    if glGetProgramiv(program_id, GL_LINK_STATUS) != GL_TRUE:
        raise RuntimeError(glGetProgramInfoLog(program_id))

    global vai, pbi, cbi, vai2, vai3
    vai, pbi, cbi = create_vertex_buffers(np.array([0, 0, 1,
                                                    1, 1, 0,
                                                    1, 0, 0,
                                                    1, -1, 0,
                                                    0, -1, 0,
                                                    -1, -1, 0,
                                                    -1, 0, 0,
                                                    -1, 1, 0,
                                                    0, 1, 0], dtype=np.float32),
                                          np.array([1, 1, 0,
                                                    0, 0, 1,
                                                    0, 1, 0,
                                                    1, 0, 0,
                                                    0, 1, 0,
                                                    0, 0, 1,
                                                    0, 1, 1,
                                                    1, 1, 1,
                                                    0, 0, 1], dtype=np.float32), program_id,
                                          sizes=np.array(
                                              [0.5, 1.5, 1.5,
                                               0.5, 1.5, 1.5,
                                               0.5, 1.5, 1.5], dtype=np.float32))
    v = []
    color = []
    for i in range(-11, 12):
        for j in range(-11, 12):
            v.append(i)
            v.append(j)
            v.append(0)
            color.append(1)
            color.append(1)
            color.append(1)

    '''vai, pbi, cbi = create_vertex_buffers(np.array(v, dtype=np.float32),
                                          np.array(color, dtype=np.float32), program_id,
                                          sizes=np.array(
                                              [0.5, 1.5, 1.5,
                                               0.5, 1.5, 1.5,
                                               0.5, 1.5, 1.5], dtype=np.float32))'''

    vai2, _, _ = create_vertex_buffers(np.array([0.4, 0.4, 0,
                                                 1, 0.4, 0,
                                                 0.4, 1, 0,
                                                 0.4, 1, 0,
                                                 1, 0.4, 0,
                                                 1, 1, 0], dtype=np.float32),
                                       np.array([0, 0, 0,
                                                 1, 0, 0,
                                                 0, 1, 0,
                                                 0, 1, 0,
                                                 1, 0, 0,
                                                 1, 1, 0], dtype=np.float32), program2_id)
    vai3, _, _ = create_vertex_buffers(np.array([-1, -1, 0,
                                                 1, -1, 0,
                                                 -1, 1, 0,
                                                 -1, 1, 0,
                                                 1, -1, 0,
                                                 1, 1, 0], dtype=np.float32),
                                       np.array([0, 0, 0,
                                                 1, 0, 0,
                                                 0, 1, 0,
                                                 0, 1, 0,
                                                 1, 0, 0,
                                                 1, 1, 0], dtype=np.float32), program2_id)
    struct.render(projMatrix, rotate(rx, 0, 0))
    my_timer(0)
    glutMainLoop()
    return


projMatrix = perspectiveMatrix(45.0, 400 / 400, 0.01, 100.0);


def check_error(message):
    gl_error = glGetError()
    if gl_error != GL_NO_ERROR:
        print("Error: " + message)
        if gluErrorString(gl_error):
            print(gluErrorString(gl_error))
        else:
            print(hex(gl_error))
        return True
    return False


def create_vertex_buffers(positions, colors, program_id, sizes=np.array([])):
    glEnableClientState(GL_VERTEX_ARRAY)
    glEnableClientState(GL_TEXTURE_COORD_ARRAY)
    glEnableClientState(GL_NORMAL_ARRAY)
    glEnableClientState(GL_COLOR_ARRAY)

    # global vai, pbi, cbi
    tvai = GLuint(0)
    tpbi = GLuint(0)
    tcbi = GLuint(0)

    # test = glGetString(GL_VERSION)

    glGenVertexArrays(1, tvai)
    glBindVertexArray(tvai)

    vid = glGetAttribLocation(program_id, "in_position")
    glEnableVertexAttribArray(vid)

    tpbi = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, tpbi)
    glBufferData(GL_ARRAY_BUFFER, positions, GL_STATIC_DRAW)
    glVertexAttribPointer(vid, 3, GL_FLOAT, GL_FALSE, 0, None)
    check_error("Could not create position buffer")

    tcbi = glGenBuffers(1)
    glBindBuffer(GL_ARRAY_BUFFER, tcbi)
    glBufferData(GL_ARRAY_BUFFER, colors, GL_STATIC_DRAW)
    vc = glGetAttribLocation(program_id, "MyInColor")
    if vc != -1:
        glEnableVertexAttribArray(vc)
        glVertexAttribPointer(vc, 3, GL_FLOAT, GL_FALSE, 0, None)
        check_error("Could not create color buffer")

    if len(sizes) > 0:
        sbi = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, sbi)
        glBufferData(GL_ARRAY_BUFFER, sizes, GL_STATIC_DRAW)
        vs = glGetAttribLocation(program_id, "MyInSize")
        if vs != -1:
            glEnableVertexAttribArray(vs)
            glVertexAttribPointer(vs, 3, GL_FLOAT, GL_FALSE, 0, None)
            check_error("Could not create size buffer")

    glBindVertexArray(0)
    return tvai, tpbi, tcbi


def clear_buffer(buffer_id):
    glDisableVertexAttribArray(buffer_id)
    glDeleteBuffers(1, [buffer_id])


def clear_vertex_array(va_id):
    glDeleteVertexArrays(1, va_id)
    check_error("Could not destroy vertex array")


vai, pbi, cbi = 0, 0, 0
vai2, pbi2, cbi2 = 0, 0, 0
vai3, pbi3, cbi3 = 0, 0, 0
rx = 0
ry = 0


def render(program_id, projMatrix, vai, x, y, z, alternateprograms=None):
    global struct, cstruct, wp

    cstruct.render(translate(x, y, z) * rotate(0, ry, 0, True) * projMatrix, rotate(rx, 0, 0), alternateprograms)
    wp.world.render(translate(x, y, z) * rotate(0, ry, 0, True) * projMatrix, rotate(rx, 0, 0), alternateprograms)
    '''
    glUseProgram(program_id)
    check_error("Renderingprogram is not initialized!")

    projection = glGetUniformLocation(program_id, 'projModelViewMatrix')
    rot = glGetUniformLocation(program_id, 'rotMatrix')

    glUniformMatrix4fv(projection, 1, GL_FALSE, np.array(translate(x, y, z) * rotate(rx, 0, 0, True) * projMatrix, dtype=np.float32))
    glUniformMatrix3fv(rot, 1, GL_FALSE, np.array(rotate(rx, 0, 0), dtype=np.float32))


    glBindVertexArray(vai)
    glDrawArrays(GL_POINTS, 0, 9)#529
    check_error("Rendering problem")

    glBindVertexArray(0)
    glUseProgram(0)
    '''


def display():
    '''if time.time() - start >= 1:
        print(frames+1)
        global start, frames
        frames = 0
        start = time.time()
    else:
        global frames
        frames += 1'''
    glClearColor(0, 0, 0, 0)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    global l
    l.prepareForDepthMapping()
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    # newMat = orthogonalMatrix(10, -10, 10, -10, 10, -10) * lookAt(cx, cy, 5, 0, 0, 0, 0, 1,0) * np.identity(4)
    # newMat = translate(0, 0, -10) * newMat

    global projMatrix
    projMatrix = perspectiveMatrix(45, float(width) / float(height), 0.01, 100.0)

    newMat = translate(-cx, -cy, -5) * lookAt(0, 0, 0, cx, cy, 5, 0, 1, 0) * perspectiveMatrix(opening,
                                                                                               float(l.map_size) /
                                                                                               float(l.map_size),
                                                                                               0.01, 100.0)
    l.pos = [-cx, -cy, -5]
    l.ModelviewProjectionMatrix = newMat
    l.lightColor = [1, 1, 1]

    glUseProgram(program3_id)
    widthid = glGetUniformLocation(program3_id, 'width')
    heightid = glGetUniformLocation(program3_id, 'height')
    nearid = glGetUniformLocation(program3_id, 'near')
    farid = glGetUniformLocation(program3_id, 'far')
    glUniform1f(nearid, 0.01)
    glUniform1f(farid, 100)
    glUniform1f(widthid, l.map_size)
    glUniform1f(heightid, l.map_size)

    altPrId = {}
    altPrId[program_id] = program3_id
    render(program3_id, newMat, vai, 0, 0, 0, altPrId)
    glFlush()
    l.finishDepthMapping()

    glClearColor(0, 0, 0, 0)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    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, width)
    glUniform1f(heightid, height)

    lightProjModelViewMatrix = glGetUniformLocation(program_id, 'lightProjModelViewMatrix')
    numLights = glGetUniformLocation(program_id, 'numLights')
    lightpos = glGetUniformLocation(program_id, 'lightpos')
    lightcolorid = glGetUniformLocation(program_id, 'lightColor')

    glUniformMatrix4fv(lightProjModelViewMatrix, 1, GL_FALSE, np.array(l.ModelviewProjectionMatrix))
    glUniform1iv(numLights, 1, 1)
    glUniform3fv(lightpos, 1, l.pos)
    glUniform3fv(lightcolorid, 1, l.lightColor)

    texID = glGetUniformLocation(program_id, 'ShadowMaps')
    glActiveTexture(GL_TEXTURE0)
    glBindTexture(GL_TEXTURE_2D, l.DepthBuffer)
    glUniform1iv(texID, 1, 0)

    glViewport(0, 0, width, height)
    render(program_id, translate(0, 0, -10) * lookAt(0, 0, 0, 0, 0, 10, 0, 1, 0) * projMatrix, vai, 0, 0, 0)

    # temp, _, _ = create_vertex_buffers(np.array([cx, cy, 5], dtype=np.float32),
    #                                    np.array([1, 1, 0], dtype=np.float32), program_id)
    # render(program_id, projMatrix, temp, 0, 0, -10)
    # ry += 0.05

    glUseProgram(program2_id)
    check_error("Renderingprogram is not initialized!")

    texID = glGetUniformLocation(program2_id, "Tex")
    glActiveTexture(GL_TEXTURE0)
    glBindTexture(GL_TEXTURE_2D, l.DepthBuffer)
    glUniform1i(texID, 0)

    glBindVertexArray(vai2)
    glDrawArrays(GL_TRIANGLES, 0, 6)
    check_error("Rendering problem")

    glBindVertexArray(0)
    glUseProgram(0)
    glFlush()

    glutSwapBuffers()
    global rx
    # rx += 0.025
    global ry
    # glutPostRedisplay()
    return


cx = 0
cy = 0


# def display2():
#     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#     global l
#     l.prepareForDepthMapping()
#     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#
#     newMat = orthogonalMatrix(10, -10, 10, -10, 20, 0.01) * lookAt(-cx, -cy, 1, 0, 0, 0, 0, 1, 0) * np.identity(4)
#     newMat = translate(5, 0, -10) * lookAt(-5, 0, 10, 0, 0, 0, 0, 1, 0) * projMatrix
#     oldMat = rotate(0, -0.5, 0, True) * projMatrix
#     glUseProgram(program3_id)
#     widthid = glGetUniformLocation(program3_id, 'width')
#     heightid = glGetUniformLocation(program3_id, 'height')
#     nearid = glGetUniformLocation(program3_id, 'near')
#     farid = glGetUniformLocation(program3_id, 'far')
#     glUniform1f(nearid, 0.01)
#     glUniform1f(farid, 100)
#     glUniform1f(widthid, width)
#     glUniform1f(heightid, height)
#     render(program3_id, newMat, vai, 0, 0, 0)
#     glFlush()
#     l.finishDepthMapping()
#
#     glUseProgram(program2_id)
#     check_error("Renderingprogram is not initialized!")
#
#     texID = glGetUniformLocation(program2_id, "Tex")
#     glActiveTexture(GL_TEXTURE0)
#     glBindTexture(GL_TEXTURE_2D, l.DepthBuffer)
#     glUniform1i(texID, 0)
#
#     glBindVertexArray(vai3)
#     glDrawArrays(GL_TRIANGLES, 0, 6)
#     check_error("Rendering problem")
#     glBindVertexArray(0)
#     glUseProgram(0)
#     glFlush()
#     glutSwapBuffers()
#     glutPostRedisplay()


def resize(w, h):
    w = max(w, 1)
    h = max(h, 1)
    glViewport(0, 0, w, h)
    global projMatrix
    projMatrix = perspectiveMatrix(45.0, float(w) / float(h), 0.01, 100.0)
    global width, height
    width = w
    height = h

def keyboardHandler(key: int, x: int, y: int):
    if key == b'\x1b':
        exit()
    global rx
    global cx
    global cy
    global opening

    if key == b'+':
        rx += 0.25
    if key == b'-':
        rx -= 0.25

    if key == b'w':
        cy += 0.25
    if key == b's':
        cy -= 0.25

    if key == b'a':
        cx -= 0.25
    if key == b'd':
        cx += 0.25

    if key == b'q':
        opening -= 0.25
    if key == b'e':
        opening += 0.25

    if key == b'r':
        print(cx, cy, opening)
    # glutPostRedisplay()
    # print(key,x,y)


def funcKeydHandler(key: int, x: int, y: int):
    if key == 11:
        glutFullScreenToggle()
    # print(key)


def my_timer(x):
    glutPostRedisplay()
    glutTimerFunc(int(1000/60), my_timer, 0)



if __name__ == '__main__':
    rx = 0
    ry = 0
    main()