Пример #1
0
def main():
    glfw.setErrorCallback(error_callback)

    glfw.init()
    glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
    glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
    glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
    # glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
    glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)

    window = glfw.createWindow(WIDTH, HEIGHT, "LearnOpenGL")

    if window is None:
        print('could not open window.')
        glfw.terminate()
        sys.exit()

    window.makeContextCurrent()
    # window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)
    window.setKeyCallback(key_callback)

    gl.init()
    err = gl.getError()
    if err:
        print("WINDOW OPEN ERROR:", err)

    # set up the first model
    armored_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "armored_plate.75.75.decimation_test7.obj"))
    armored_plate_model = Model.FromJSON(armored_plate_data, InstanceData, PlateInstance)

    plane_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "plane_plate.75.75.decimation_test.00.obj"))
    plane_plate_model = Model.FromJSON(plane_plate_data, InstanceData, PlateInstance)

    angled_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_plate_plane.75.25..25.decimated.obj"))
    angled_plate_model = Model.FromJSON(angled_plate_data, InstanceData, PlateInstance)

    models =[armored_plate_model, plane_plate_model, angled_plate_model]

    scene = Scene()
    camera = Camera(name='camera', parent=scene)

    # set up the data for the instances.
    # 30 x 30 array of tiles, which are randomly selected among the above models
    instances = {}
    transforms = {}
    n = 30
    for i in range(n):
        for j in range(n):
            r = random.choice(range(4))
            transform = Mat4.Translation(Vec3((i-n//2) * 2, 0.0, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * r, Vec3(0.0, 1.0, 0.0))
            transform_node = TransformNode3D(name='tranform.%i.%i' % (i, j), parent=scene, m=transform)
            transforms[i,j] = transform_node
            instance = ModelInstance(random.choice(models), model_matrix=transform, parent=transform_node, name='model.%i.%i' % (i,j))
            instance.model_matrix = transform
            instances[i,j] = instance
            instance.r = r

    framebuffer_width, framebuffer_height = window.getFramebufferSize()
    camera.projection_matrix = Mat4.Perspective(45.0, framebuffer_width/framebuffer_height, 0.1, 100.0)
    camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock()), 1.0, math.sin(time.clock())) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
    
    t0 = time.perf_counter()
    frames = 0
    while not window.shouldClose():
        glfw.pollEvents()

        gl.enable(gl.DEPTH_TEST)
        gl.depthFunc(gl.LEQUAL)

        gl.enable(gl.CULL_FACE)
        gl.cullFace(gl.BACK)

        t = time.perf_counter()

        framebuffer_width, framebuffer_height = window.getFramebufferSize()
        camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
        viewport = (0, 0, framebuffer_width, framebuffer_height)
        camera.render_to_viewport(viewport)

        err = gl.getError()
        if err:
            print("ERROR:", err)

        if TEST_ANIMATION:
            for i in range(n):
                for j in range(n):
                    instance = instances[i,j]
                    enabled = math.sin(i+j+t*10.0) > -0.8
                    instance.set_enabled(enabled)
                    if enabled:
                        transform_node = transforms[i,j]
                        y = (math.sin(t+i) + math.cos(t+j)) * 0.25
                        transform = Mat4.Translation(Vec3((i-n//2) * 2, y, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * instance.r, Vec3(0.0, 1.0, 0.0))
                        transform_node.local_matrix = transform

                        # TODO: this should be done automatically in nodetree.graphics.Scene.update_instances
                        instance.instance.model_matrix = transform_node.to_mat4()
                  

        scene.update_instances()

        window.swapBuffers()

        frames += 1
        if not frames % 100:
            print("FRAME RATE:", float(frames)/(time.perf_counter() - t0))
Пример #2
0
def main():
    glfw.setErrorCallback(error_callback)

    glfw.init()
    glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
    glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
    glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
    glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
    glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)

    window = glfw.createWindow(WIDTH, HEIGHT, "LearnOpenGL")

    if window is None:
        # print('could not open window.')
        glfw.terminate()
        sys.exit()


    cursor = Vec2()
    window_size = Vec2(WIDTH, HEIGHT)
    ui = EventEmitter()

    def mouse_move_callback(window, x, y):
        nonlocal cursor
        # print('mouse move:', window, x, y)
        cursor = Vec2(x, window_size.y - y)
        ui.emit('mouse_move', window, cursor)

    def mouse_button_callback(window, button, action, mods):
        print('mouse button:', window, button, action, mods)
        ui.emit('mouse_button', window, button, action, mods)

    def window_size_callback(window, width, height):
        nonlocal window_size
        window_size.x = width
        window_size.y = height

    window.makeContextCurrent()
    # window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)
    window.setKeyCallback(key_callback)
    window.setMouseButtonCallback(mouse_button_callback)
    window.setCursorPosCallback(mouse_move_callback)
    window.setWindowSizeCallback(window_size_callback)

    gl.init()
    err = gl.getError()
    if err:
        print("WINDOW OPEN ERROR:", err)


    # pre game-loop initialization
    scene = Scene()

    # construct the triangle
    triangle_points = Vector(Vec3)
    triangle_points.append(Vec3(-0.5, -0.5, 0.0))
    triangle_points.append(Vec3( 0.5, -0.5, 0.0))
    triangle_points.append(Vec3(-0.5,  0.5, 0.0))

    triangle_indices = Vector(c_ubyte)
    triangle_indices.append(0)
    triangle_indices.append(1)
    triangle_indices.append(2)

    triangle_attribs = BufferAttribs(sizeof(Vec3))
    triangle_attribs.add(BufferAttribs.POSITION_INDEX, 3, gl.FLOAT, gl.FALSE, 0)

    triangle_shader = ShaderProgram(VERTEX_SHADER_SOURCE, FRAGMENT_SHADER_SOURCE)

    triangle_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.LINE_LOOP, 0, len(triangle_indices))

    triangle_material = {}

    triangle_mesh = Mesh(triangle_shader, triangle_draw_call, triangle_material)

    triangle_model = Model(triangle_indices.get_data(), triangle_points.get_data(), triangle_attribs, [triangle_mesh], InstanceData, ItemInstance)

    triangle_instance = scene.add(triangle_model, InstanceData(model_matrix=Mat4.Identity(), base_color=Vec3(1.0, 0.0, 0.0)))

    # construct the reticle
    RETICLE_SIZE = 0.01
    reticle_points = Vector(Vec3)
    reticle_points.append(Vec3(-RETICLE_SIZE * 0.5, -RETICLE_SIZE * 0.5, 0.0))
    reticle_points.append(Vec3(-RETICLE_SIZE * 0.5,  RETICLE_SIZE * 0.5, 0.0))
    reticle_points.append(Vec3( RETICLE_SIZE * 0.5,  RETICLE_SIZE * 0.5, 0.0))
    reticle_points.append(Vec3( RETICLE_SIZE * 0.5, -RETICLE_SIZE * 0.5, 0.0))

    reticle_indices = Vector(c_ubyte)
    reticle_indices.append(0)
    reticle_indices.append(1)
    reticle_indices.append(2)
    reticle_indices.append(3)


    reticle_attribs = BufferAttribs(sizeof(Vec3))
    reticle_attribs.add(BufferAttribs.POSITION_INDEX, 3, gl.FLOAT, gl.FALSE, 0)

    reticle_shader = triangle_shader

    reticle_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.LINE_LOOP, 0, len(reticle_indices))

    reticle_material = {}

    reticle_mesh = Mesh(reticle_shader, reticle_draw_call, reticle_material)

    reticle_model = Model(reticle_indices.get_data(), reticle_points.get_data(), reticle_attribs, [reticle_mesh], InstanceData, ItemInstance)

    # construct the AABB model
    aabb = AABB3()
    aabb.include_point(Vec3(0.0, 0.0, 0.0))
    aabb.include_point(Vec3(0.2, 0.2, 0.2))

    aabb_points = Vector(Vec3)
    aabb_points.append(Vec3(aabb.min.x, aabb.min.y, aabb.min.z))
    aabb_points.append(Vec3(aabb.max.x, aabb.min.y, aabb.min.z))
    aabb_points.append(Vec3(aabb.min.x, aabb.max.y, aabb.min.z))
    aabb_points.append(Vec3(aabb.max.x, aabb.max.y, aabb.min.z))
    aabb_points.append(Vec3(aabb.min.x, aabb.min.y, aabb.max.z))
    aabb_points.append(Vec3(aabb.max.x, aabb.min.y, aabb.max.z))
    aabb_points.append(Vec3(aabb.min.x, aabb.max.y, aabb.max.z))
    aabb_points.append(Vec3(aabb.max.x, aabb.max.y, aabb.max.z))

    # lines
    aabb_indices = Vector(c_ubyte)
    aabb_indices.append(0)
    aabb_indices.append(1)

    aabb_indices.append(2)
    aabb_indices.append(3)

    aabb_indices.append(4)
    aabb_indices.append(5)

    aabb_indices.append(6)
    aabb_indices.append(7)

    aabb_indices.append(0)
    aabb_indices.append(4)

    aabb_indices.append(1)
    aabb_indices.append(5)

    aabb_indices.append(2)
    aabb_indices.append(6)

    aabb_indices.append(3)
    aabb_indices.append(7)

    aabb_indices.append(0)
    aabb_indices.append(2)

    aabb_indices.append(1)
    aabb_indices.append(3)

    aabb_indices.append(4)
    aabb_indices.append(6)

    aabb_indices.append(5)
    aabb_indices.append(7)


    aabb_attribs = BufferAttribs(sizeof(Vec3))
    aabb_attribs.add(BufferAttribs.POSITION_INDEX, 3, gl.FLOAT, gl.FALSE, 0)

    aabb_shader = triangle_shader

    aabb_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.LINES, 0, len(aabb_indices))

    aabb_material = {}

    aabb_mesh = Mesh(aabb_shader, aabb_draw_call, aabb_material)

    aabb_model = Model(aabb_indices.get_data(), aabb_points.get_data(), aabb_attribs, [aabb_mesh], InstanceData, ItemInstance)

    # reticle_instances = ModelInstances(reticle_model, InstanceData, ItemInstance)
    reticle_instance = scene.add(reticle_model, InstanceData(model_matrix=Mat4.Identity()))

    # aabb_instances = ModelInstances(aabb_model, InstanceData, ItemInstance)
    aabb_instance = scene.add(aabb_model, InstanceData(model_matrix=Mat4.Identity()))
    #reticle_instance.set_enabled(False)


    ray_scene = RayScene()
    # ui.on('mouse_move' lambda window, cursor: scene.mouse_move(camera, viewport, cursor))

    camera = Camera(scene=scene)

    framebuffer_width, framebuffer_height = window.getFramebufferSize()
    # camera.projection_matrix = Mat4.Identity()
    camera.projection_matrix = Mat4.Perspective(45.0, framebuffer_width/framebuffer_height, 0.1, 100.0)
    camera.view_matrix = Mat4.Identity()

    t0 = time.perf_counter()
    frames = 0
    while not window.shouldClose():
        glfw.pollEvents()

        gl.enable(gl.DEPTH_TEST)
        gl.depthFunc(gl.LEQUAL)

        gl.enable(gl.CULL_FACE)
        gl.cullFace(gl.BACK)

        t = time.perf_counter()

        err = gl.getError()
        if err:
            print("ERROR:", err)

        # render the frame
        framebuffer_width, framebuffer_height = window.getFramebufferSize()
        # camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
        camera.view_matrix = Mat4.LookAt(
            Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *2.0, 
            Vec3(0.0, 0.0, 0.0), 
            Vec3(0.0, 1.0, 0.0)
        )

        viewport = (0, 0, framebuffer_width, framebuffer_height)
 
        camera.render_to_viewport(viewport)

        # not sure if this is correct when the viewport size doesn't match the framebuffer size.
        ray_origin, ray_direction = camera.get_ray(cursor, viewport)

        # print(ray)

        result = raytri.intersect_triangle(ray_origin, ray_direction, *triangle_points)

        if result:
            t, u, v = result
            hit_pos = triangle_points[0] * (1.0 - u - v) + triangle_points[1] * u + triangle_points[2] * v
            reticle_instance.set_enabled(True)
            reticle_instance.model_matrix = Mat4.Translation(hit_pos)
            reticle_instance.base_color = Vec3(1.0, 1.0, 1.0)
            triangle_instance.base_color = Vec3(1.0, 0.0, 0.0)
        else:
            reticle_instance.set_enabled(False)
            triangle_instance.base_color = Vec3(1.0, 1.0, 1.0)
            reticle_instance.base_color = Vec3(0.0, 0.0, 0.0)

        result = raytri.hit_aabb(ray_origin, ray_direction, aabb)

        if result:
            aabb_instance.base_color = Vec3(1.0, 0.0, 0.0)
        else:
            aabb_instance.base_color = Vec3(1.0, 1.0, 1.0)

        # print((ray_origin, ray_direction), result)

        # update buffers
        scene.update_instances()

        window.swapBuffers()

        frames += 1
        if not frames % 100:
            print("FRAME RATE:", float(frames)/(time.perf_counter() - t0))
Пример #3
0
def main():
    glfw.setErrorCallback(error_callback)

    glfw.init()
    glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
    glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
    glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
    # glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
    glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)

    if ENABLE_MULTISAMPLE:
        glfw.windowHint(glfw.SAMPLES, 4)

    window = glfw.createWindow(WIDTH, HEIGHT, "LearnOpenGL")

    if window is None:
        print('could not open window.')
        glfw.terminate()
        sys.exit()

    window.makeContextCurrent()
    # window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)
    window.setKeyCallback(key_callback)

    gl.init()
    err = gl.getError()
    if err:
        print("WINDOW OPEN ERROR:", err)


    framebuffer_width, framebuffer_height = window.getFramebufferSize()

    # Framebuffers
    framebuffer = gl.genFramebuffers(1)[0]
    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 

    # Create a color attachment texture
    textureColorbuffer = generateAttachmentTexture(gl.RGB, framebuffer_width, framebuffer_height);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, textureColorbuffer, 0)

    # set up the position buffer
    gPosition = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gPosition)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, gPosition, 0)

    # set up the normal buffer
    gNormal = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gNormal)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, gl.TEXTURE_2D, gNormal, 0)

    gLight = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gLight)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT3, gl.TEXTURE_2D, gLight, 0)
    # - Tell OpenGL which color attachments we'll use (of this framebuffer) for rendering
    attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]
    gl.drawBuffers(attachments)


    gDepth = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gDepth)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH24_STENCIL8, framebuffer_width, framebuffer_height, 0, gl.DEPTH_STENCIL, gl.UNSIGNED_INT_24_8, None)
    # gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.TEXTURE_2D, gDepth, 0)

    # Create a renderbuffer object for depth and stencil attachment (we won't be sampling these)
    # rbo = gl.genRenderbuffers(1)[0]
    # gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)
    # gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, framebuffer_width, framebuffer_height); # Use a single renderbuffer object for both a depth AND stencil buffer.
    # gl.bindRenderbuffer(gl.RENDERBUFFER, 0);
    # gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, rbo) # Now actually attach it

    # Now that we actually created the framebuffer and added all attachments we want to check if it is actually complete now
    if gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE:
        print("ERROR::FRAMEBUFFER:: Framebuffer is not complete!")

    gl.bindFramebuffer(gl.FRAMEBUFFER, 0)


    deferred_textures = {
        'screenTexture': textureColorbuffer,
        'normalTexture': gNormal,
        'positionTexture': gPosition,
        'lightTexture': gLight,
        'depthTexture': gDepth
    }


    scene = Scene()
    camera = Camera(scene=scene)

    quad_scene = Scene()
    quad_camera = Camera(scene=quad_scene)

    light_scene = Scene()
    light_camera = Camera(scene=light_scene, clear=0)
    light_camera.clear = gl.COLOR_BUFFER_BIT
    light_camera.clear_color = (0.0, 0.0, 0.0, 0.0)

    light_camera.projection_matrix = camera.projection_matrix = Mat4.Perspective(45.0, framebuffer_width/framebuffer_height, 0.1, 100.0)
    light_camera.view_matrix = camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock()), 1.0, math.sin(time.clock())) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))

    # light volume model
    light_volume_data = objloader.load_obj(os.path.join("springtangent-model-files", "lightsphere", "lightsphere.obj"), calculate_normals=True)
    light_volume_model = Model.FromJSON(light_volume_data, PointLightInstanceData, PlateInstance)

    # other models
    armored_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "armored_plate.75.75.decimation_test7.obj"), calculate_normals=True)
    armored_plate_model = Model.FromJSON(armored_plate_data, InstanceData, PlateInstance)

    plane_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "plane_plate.75.75.decimation_test.00.obj"), calculate_normals=True)
    plane_plate_model = Model.FromJSON(plane_plate_data, InstanceData, PlateInstance)

    angled_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_plate_plane.75.25..25.decimated.obj"), calculate_normals=True)
    angled_plate_model = Model.FromJSON(angled_plate_data, InstanceData, PlateInstance)

    angled_to_rounded_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_to_round_adapter.75.25.25", "angled_to_rounded_adapter.75.25.25.decimated.obj"), calculate_normals=True)
    angled_to_rounded_model = Model.FromJSON(angled_to_rounded_data, InstanceData, PlateInstance)

    models = [armored_plate_model, plane_plate_model, angled_plate_model, angled_to_rounded_model]

    deferred_shader = ShaderProgram(GBUFFER_VERT, GBUFFER_FRAG)
    deferred_light_shader = ShaderProgram(GBUFFER_LIGHT_VERT, GBUFFER_LIGHT_FRAG)

    for mesh in light_volume_model.meshes:
        mesh.shader = deferred_light_shader
        mesh.material = deferred_textures

    # replace the shader with the deferred shader in all meshes
    for model in models:
        for mesh in model.meshes:
            mesh.shader = deferred_shader


    # set up the data for the instances.
    # 30 x 30 array of tiles, which are randomly selected among the above models
    n = 30
    instances = {}
    for i in range(n):
        for j in range(n):
            r = random.choice(range(4))
            transform = Mat4.Translation(Vec3((i-n//2) * 2, 0.0, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * r, Vec3(0.0, 1.0, 0.0))
            instance = scene.add(random.choice(models), InstanceData(transform))
            instance.r = r
            instances[i,j] = instance

    nlights = 400
    for i in range(nlights):
        transform = Mat4.Translation(Vec3(random.uniform(-n/2, n/2), random.uniform(-1.0, 1.0), random.uniform(-n/2,n/2))) * Mat4.Scale(random.uniform(2.0, 10.0))
        instance = light_scene.add(light_volume_model, PointLightInstanceData(transform, diffuse=Vec3(1.0, 1.0, 1.0), linear_attenuation=0.1, quadratic_attenutation=0.01))

    # full screen rectangle
    class QuadVert(Structure):
        _fields_ = [
            ('position', Vec2),
            ('texcoord', Vec2)
        ]

    quad_points = Vector(QuadVert)
    quad_points.append(QuadVert(Vec2(-1.0,  1.0), Vec2(0.0, 1.0)))
    quad_points.append(QuadVert(Vec2(-1.0, -1.0), Vec2(0.0, 0.0)))
    quad_points.append(QuadVert(Vec2( 1.0, -1.0), Vec2(1.0, 0.0)))
    quad_points.append(QuadVert(Vec2( 1.0,  1.0), Vec2(1.0, 1.0)))

    quad_indices = Vector(c_ubyte)
    quad_indices.append(0)
    quad_indices.append(1)
    quad_indices.append(2)
    quad_indices.append(0)
    quad_indices.append(2)
    quad_indices.append(3)


    quad_attribs = BufferAttribs(sizeof(QuadVert))
    quad_attribs.add(BufferAttribs.POSITION_INDEX, 2, gl.FLOAT, gl.FALSE, QuadVert.position.offset)
    quad_attribs.add(BufferAttribs.TEXCOORD_INDEX, 2, gl.FLOAT, gl.FALSE, QuadVert.texcoord.offset)

    quad_shader = ShaderProgram(FRAMEBUFFER_VERT, FRAMEBUFFER_FRAG)

    quad_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.TRIANGLES, 0, len(quad_indices))

    quad_material = deferred_textures

    quad_mesh = Mesh(quad_shader, quad_draw_call, quad_material)

    quad_model = Model(quad_indices.get_data(), quad_points.get_data(), quad_attribs, [quad_mesh], InstanceData, PlateInstance)

    # quad_instances = ModelInstances(quad_model)

    quad_instance = quad_scene.add(quad_model, InstanceData(Mat4.Identity()))

    
    gl.enable(gl.MULTISAMPLE)
    t0 = time.perf_counter()
    frames = 0
    while not window.shouldClose():
        glfw.pollEvents()

        t = time.perf_counter()

        # render scene to gbuffer
        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer)

        gl.enable(gl.DEPTH_TEST)
        gl.depthFunc(gl.LEQUAL)

        gl.enable(gl.CULL_FACE)
        gl.cullFace(gl.BACK)

        # set up gbuffer for writing
        attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]
        gl.drawBuffers(attachments)

        framebuffer_width, framebuffer_height = window.getFramebufferSize()
        light_camera.view_matrix = camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
        viewport = (0, 0, framebuffer_width, framebuffer_height)
        camera.render_to_viewport(viewport)


        # render lights to gbuffer
        gl.drawBuffer(gl.COLOR_ATTACHMENT3)
        gl.depthFunc(gl.GREATER)

        gl.enable(gl.CULL_FACE)
        gl.cullFace(gl.FRONT)

        gl.enable(gl.BLEND)
        gl.blendEquation(gl.FUNC_ADD)
        gl.blendFunc(gl.ONE, gl.ONE)

        light_camera.render_to_viewport(viewport)

        err = gl.getError()
        if err:
            print("ERROR:", err)


        if TEST_ANIMATION:
            for i in range(n):
                for j in range(n):
                    instance = instances[i,j]
                    enabled = True # math.sin(i+j+t*10.0) > -0.8
                    # instance.set_enabled(enabled)
                    if enabled:
                        y = (math.sin(t+i) + math.cos(t+j)) * 0.25
                        transform = Mat4.Translation(Vec3((i-n//2) * 2, y, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * instance.r, Vec3(0.0, 1.0, 0.0))
                        instance.model_matrix = transform

        # render quad with texture
        gl.bindFramebuffer(gl.FRAMEBUFFER, 0)

        gl.disable(gl.BLEND)
        gl.disable(gl.CULL_FACE)
        gl.disable(gl.DEPTH_TEST) # We don't care about depth information when rendering a single quad

        quad_camera.clear_color = (1.0, 1.0, 1.0, 1.0)
        quad_camera.clear = gl.COLOR_BUFFER_BIT
        quad_camera.render_to_viewport(viewport)

        scene.update_instances()
        quad_scene.update_instances()
        light_scene.update_instances()

        window.swapBuffers()

        frames += 1
        if not frames % 100:
            print("FRAME RATE:", float(frames)/(time.perf_counter() - t0))