change

10 files changed, 599 insertions, 0 deletions

diff --git a/advanced_lighting/3.1.shadow_mapping/build.sh b/advanced_lighting/3.1.shadow_mapping/build.sh
new file mode 100755
index 0000000..bba445d
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/build.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+. ../../config
+TARGET='shadow_mapping'
+set -x
+gcc -o $TARGET $CFLAGS $INCLUDE $LFLAGS $TARGET.c $LIBS
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/color.fs b/advanced_lighting/3.1.shadow_mapping/shaders/color.fs
new file mode 100644
index 0000000..bd00d82
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/color.fs
@@ -0,0 +1,9 @@
+#version 330 core
+
+out vec4 frag_color;
+
+void
+main(void)
+{
+    frag_color = vec4(1.0);
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/color.vs b/advanced_lighting/3.1.shadow_mapping/shaders/color.vs
new file mode 100644
index 0000000..ade669b
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/color.vs
@@ -0,0 +1,12 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+
+uniform mat4 projection;
+uniform mat4 view;
+uniform mat4 model;
+
+void
+main(void)
+{
+    gl_Position = projection*view*model*vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/debug_quad.fs b/advanced_lighting/3.1.shadow_mapping/shaders/debug_quad.fs
new file mode 100644
index 0000000..d250894
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/debug_quad.fs
@@ -0,0 +1,27 @@
+#version 330 core
+
+in vec2 tex_coords;
+
+out vec4 frag_color;
+
+uniform sampler2D depth_map;
+uniform float near;
+uniform float far;
+
+float
+linearize_depth(float depth)
+{
+    float z = (depth+1.0)*0.5;
+    return((2.0*near*far)/(far+near-z*(far-near)));
+}
+
+void
+main(void)
+{
+    float depth = texture(depth_map, tex_coords).r;
+
+    /* frag_color = vec4(vec3(depth), 1.0); */
+
+    /* NOTE(pryazha): For visual debugging of perspective projection light */
+    frag_color = vec4(vec3(linearize_depth(depth)/far), 1.0);
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/debug_quad.vs b/advanced_lighting/3.1.shadow_mapping/shaders/debug_quad.vs
new file mode 100644
index 0000000..5717608
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/debug_quad.vs
@@ -0,0 +1,14 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+layout(location = 1) in vec2 atex_coords;
+
+out vec2 tex_coords;
+
+uniform mat4 model;
+
+void
+main(void)
+{
+    tex_coords = atex_coords;
+    gl_Position = model*vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/shadow.fs b/advanced_lighting/3.1.shadow_mapping/shaders/shadow.fs
new file mode 100644
index 0000000..1c7018a
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/shadow.fs
@@ -0,0 +1,72 @@
+#version 330 core
+
+in VS_OUT {
+    vec4 frag_pos_light_space;
+    vec3 frag_pos;
+    vec3 normal;
+    vec2 tex_coords;
+} fs_in;
+
+out vec4 frag_color;
+
+uniform vec3 light_pos;
+uniform vec3 view_pos;
+
+uniform sampler2D diffuse_texture;
+uniform sampler2D shadow_map;
+
+float
+calculate_shadow()
+{
+    vec3 proj_coords = fs_in.frag_pos_light_space.xyz/fs_in.frag_pos_light_space.w;
+    proj_coords = proj_coords*0.5+0.5;
+    float closest_depth = texture(shadow_map, proj_coords.xy).r;
+    float current_depth = proj_coords.z;
+    vec3 normal = normalize(fs_in.normal);
+    vec3 light_dir = normalize(light_pos-fs_in.frag_pos);
+    float bias = max(0.04*(1.0-dot(normal, light_dir)), 0.004);
+    float shadow = 0;
+    vec2 texel_size = 1.0/textureSize(shadow_map, 0);
+    for (int x = -1; x <= 1; x++)
+    {
+        for (int y = -1; y <= 1; y++)
+        {
+            float pcf_depth = texture(shadow_map, proj_coords.xy+vec2(x, y)*texel_size).r;
+            shadow += (current_depth-bias > pcf_depth) ? 1.0 : 0.0;
+        }
+    }
+    shadow /= 9.0;
+
+    if (proj_coords.z > 1.0)
+        shadow = 0.0;
+    
+    return(shadow);
+}
+
+void
+main(void)
+{
+    vec3 color = texture(diffuse_texture, fs_in.tex_coords).rgb;
+    vec3 normal = normalize(fs_in.normal);
+    vec3 light_color = vec3(0.3);
+
+    float ambient_strength = 0.01;
+    vec3 ambient = color*ambient_strength;
+    
+    vec3 light_dir = normalize(light_pos-fs_in.frag_pos);
+    float diff = max(dot(light_dir, normal), 0.0);
+    vec3 diffuse = diff*color;
+
+    vec3 view_dir = normalize(view_pos-fs_in.frag_pos);
+    vec3 halfway_dir = normalize(light_dir+view_dir); 
+    float spec = pow(max(dot(halfway_dir, normal), 0.0), 64.0);
+    vec3 specular = spec*color;
+
+    float shadow = calculate_shadow();
+    vec3 lighting = ambient+((diffuse+specular)*(1.0-shadow)*light_color);
+
+    float gamma = 2.2;
+    lighting = pow(lighting, vec3(1.0/gamma));
+
+    frag_color = vec4(lighting, 1.0);
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/shadow.vs b/advanced_lighting/3.1.shadow_mapping/shaders/shadow.vs
new file mode 100644
index 0000000..3ecd5b1
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/shadow.vs
@@ -0,0 +1,26 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+layout(location = 1) in vec3 anormal;
+layout(location = 2) in vec2 atex_coords;
+
+out VS_OUT {
+    vec4 frag_pos_light_space;
+    vec3 frag_pos;
+    vec3 normal;
+    vec2 tex_coords;
+} vs_out;
+
+uniform mat4 projection;
+uniform mat4 view;
+uniform mat4 model;
+uniform mat4 light_space_matrix;
+
+void
+main(void)
+{
+    vs_out.frag_pos = vec3(model*vec4(apos, 1.0));
+    vs_out.frag_pos_light_space = light_space_matrix*vec4(vs_out.frag_pos, 1.0);
+    vs_out.normal = mat3(transpose(inverse(model)))*anormal;
+    vs_out.tex_coords = atex_coords;
+    gl_Position = projection*view*vec4(vs_out.frag_pos, 1.0);
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/simple_depth.fs b/advanced_lighting/3.1.shadow_mapping/shaders/simple_depth.fs
new file mode 100644
index 0000000..16b9908
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/simple_depth.fs
@@ -0,0 +1,6 @@
+#version 330 core
+
+void
+main(void)
+{
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shaders/simple_depth.vs b/advanced_lighting/3.1.shadow_mapping/shaders/simple_depth.vs
new file mode 100644
index 0000000..b9752ed
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shaders/simple_depth.vs
@@ -0,0 +1,11 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+
+uniform mat4 light_space_matrix;
+uniform mat4 model;
+
+void
+main(void)
+{
+    gl_Position = light_space_matrix*model*vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/3.1.shadow_mapping/shadow_mapping.c b/advanced_lighting/3.1.shadow_mapping/shadow_mapping.c
new file mode 100644
index 0000000..7f03415
--- /dev/null
+++ b/advanced_lighting/3.1.shadow_mapping/shadow_mapping.c
@@ -0,0 +1,417 @@
+#include "pwyazh.h"
+
+#include "GL/glew.h"
+#include "GLFW/glfw3.h"
+
+#include "pwyazh_GL.h"
+
+#include "common.h"
+
+static S32 global_screen_width = 800, global_screen_height = 600;
+static U32 global_shadow_width = 1024, global_shadow_height = 1024;
+
+static Input global_input;
+
+static V3F camera_dp = (V3F){ 0.0f, 0.0f, 0.0f };
+
+static U32 global_depth_map_fbo, global_depth_map;
+
+static U32 global_debug_quad_shader, global_simple_depth_shader,
+           global_shadow_shader, global_color_shader;
+
+static U32 global_wood_texture;
+
+static U32 global_quad_vao;
+
+static U32 shadows_ortho = 1;
+
+static V3F light_pos;
+
+void
+glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    switch (action)
+    {
+        case GLFW_PRESS: {
+            switch (key)
+            {
+                case GLFW_KEY_D: {
+                    global_input.move_right.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_W: {
+                    global_input.move_forward.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_A: {
+                    global_input.move_left.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_S: {
+                    global_input.move_backward.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_E: {
+                    global_input.move_up.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_Q: {
+                    global_input.move_down.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_SPACE: {
+                    global_input.jump.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_RIGHT: {
+                    global_input.action_right.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_UP: {
+                    global_input.action_up.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_LEFT: {
+                    global_input.action_left.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_DOWN: {
+                    global_input.action_down.state = KeyState_PRESS;
+                } break;
+                case GLFW_KEY_ESCAPE: {
+                    global_input.exit.state = KeyState_PRESS;
+                } break;
+            }
+        } break;
+        
+        case GLFW_RELEASE: {
+            switch (key)
+            {
+                case GLFW_KEY_D: {
+                    global_input.move_right.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_W: {
+                    global_input.move_forward.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_A: {
+                    global_input.move_left.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_S: {
+                    global_input.move_backward.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_E: {
+                    global_input.move_up.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_Q: {
+                    global_input.move_down.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_SPACE: {
+                    global_input.jump.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_RIGHT: {
+                    global_input.action_right.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_UP: {
+                    global_input.action_up.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_LEFT: {
+                    global_input.action_left.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_DOWN: {
+                    global_input.action_down.state = KeyState_RELEASE;
+                } break;
+                case GLFW_KEY_ESCAPE: {
+                    global_input.exit.state = KeyState_RELEASE;
+                } break;
+            }
+        } break;
+    }
+}
+
+void
+resize_callback(GLFWwindow* window, int width, int height)
+{
+    global_screen_width = width;
+    global_screen_height = height;
+    glViewport(0, 0, global_screen_width, global_screen_height);
+}
+
+void
+error_callback(int error, const char *desc)
+{
+    fprintf(stderr, "[ERROR] GLFW: %s\n", desc);
+}
+
+void
+update(State *state, F32 time)
+{
+    F32 radius;
+
+    V3F camera_dv = get_dv_camera_orbital(&global_input, state->camera.pos,
+                                          v3f_zero(), state->dt, 2.0f);
+    if (key_is_pressed(global_input.action_up))
+        camera_dv = v3f_scalef(camera_dv, 3.0f);
+    camera_dp = v3f_add(camera_dp, camera_dv);
+    camera_dp = v3f_scalef(camera_dp, 0.8f);
+    state->camera.pos = v3f_add(state->camera.pos, camera_dp);
+
+    if (key_first_press(global_input.action_down))
+        shadows_ortho = !shadows_ortho;
+    
+    input_update_last_state(&global_input);
+
+    F32 x, z, angular_speed;
+
+    angular_speed = 1.0f;
+    radius = 4.0f;
+    x = f32_sin(time*angular_speed)*radius;
+    z = f32_cos(time*angular_speed)*radius;
+
+    light_pos = v3f(x, 4.0f, z);
+}
+
+void
+render_scene(U32 shader, Mesh *cube, Mesh *plane)
+{
+    MAT4 model;
+
+    model = mat4_identity();
+    shader_set_mat4fv(shader, "model", model); 
+    mesh_draw(plane);
+
+    /*
+    model = mat4_identity();
+    model = mat4_make_scale(v3f(10.0f, 0.1f, 10.0f));
+    model = mat4_translate(model, v3f(0.0f, -0.6f, 0.0f));
+    shader_set_mat4fv(shader, "model", model);
+    mesh_draw(cube);
+    */
+
+    model = mat4_identity();
+    model = mat4_make_scale(v3f(0.5f, 0.5f, 0.5f));
+    model = mat4_translate(model, v3f(0.0f, 1.5f, 0.0f));
+    shader_set_mat4fv(shader, "model", model);
+    mesh_draw(cube);
+
+    model = mat4_identity();
+    model = mat4_make_scale(v3f(0.5f, 0.5f, 0.5f));
+    model = mat4_translate(model, v3f(2.0f, 0.0f, 1.0f));
+    shader_set_mat4fv(shader, "model", model);
+    mesh_draw(cube);
+
+    model = mat4_identity();
+    model = mat4_make_scale(v3f(0.25f, 0.25f, 0.25f));
+    model = mat4_rotate_angles(model, v3f(60.0f, 0.0f, 0.0f));
+    model = mat4_translate(model, v3f(-1.0f, 0.0f, 2.0f));
+    shader_set_mat4fv(shader, "model", model);
+    mesh_draw(cube);
+}
+
+void
+render(State *state, Mesh *cube, Mesh *plane)
+{
+    /* MAT4 projection, view, model; */
+    MAT4 light_projection, light_view, model;
+    F32 near, far, fovx;
+    V3F target, up;
+
+    if (shadows_ortho)
+    {
+        near = 1.0f;
+        far = 10.0f;
+        F32 half_side = 10.0f;
+        light_projection = ortho(-half_side, half_side, -half_side, half_side, near, far);
+    }
+    else
+    {
+        fovx = 90.0f;
+        near = 1.0f;
+        far = 50.0f;
+        light_projection = perspective(fovx, (F32)global_shadow_width/(F32)global_shadow_height,
+                                       near, far);
+    }
+
+    target = v3f_zero();
+    up = v3f(0.0f, 1.0f, 0.0f);
+    light_view = look_at(light_pos, target, up);
+    MAT4 light_space_matrix = mat4_mul(light_projection, light_view);
+
+    glUseProgram(global_simple_depth_shader);
+    shader_set_mat4fv(global_simple_depth_shader, "light_space_matrix", light_space_matrix); 
+    glViewport(0, 0, global_shadow_width, global_shadow_height);
+    glBindFramebuffer(GL_FRAMEBUFFER, global_depth_map_fbo);
+    glClear(GL_DEPTH_BUFFER_BIT);
+    // glCullFace(GL_FRONT);
+    render_scene(global_simple_depth_shader, cube, plane);
+    // glCullFace(GL_BACK);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    glViewport(0, 0, global_screen_width, global_screen_height);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    MAT4 projection = perspective(state->camera.fovx, (F32)global_screen_width/(F32)global_screen_height,
+                                  state->camera.near, state->camera.far);
+    MAT4 view = look_at(state->camera.pos, v3f_zero(), v3f(0.0f, 1.0f, 0.0f));
+    glUseProgram(global_shadow_shader);
+    shader_set_mat4fv(global_shadow_shader, "projection", projection); 
+    shader_set_mat4fv(global_shadow_shader, "view", view);
+
+    shader_set_3fv(global_shadow_shader, "light_pos", light_pos);
+    shader_set_3fv(global_shadow_shader, "view_pos", state->camera.pos);
+    shader_set_mat4fv(global_shadow_shader, "light_space_matrix", light_space_matrix); 
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, global_wood_texture);
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, global_depth_map);
+    render_scene(global_shadow_shader, cube, plane);
+
+    glUseProgram(global_color_shader);
+    shader_set_mat4fv(global_shadow_shader, "projection", projection); 
+    shader_set_mat4fv(global_shadow_shader, "view", view);
+    model = mat4_make_scale(v3f(0.1f, 0.1f, 0.1f));
+    model = mat4_translate(model, light_pos);
+    shader_set_mat4fv(global_shadow_shader, "model", model);
+    mesh_draw(cube);
+
+    glDisable(GL_DEPTH_TEST);
+    glUseProgram(global_debug_quad_shader);
+    F32 scale = 0.3f;
+    Transform transform = transform_make_scale_translate(v3f(scale, scale, scale),
+                                                         v3f(1.0f-scale, 1.0f-scale, 0.0f));
+    model = transform_apply(transform);
+    shader_set_mat4fv(global_debug_quad_shader, "model", model);
+    shader_set_1f(global_debug_quad_shader, "near", near);
+    shader_set_1f(global_debug_quad_shader, "far", far);
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, global_depth_map);
+    glBindVertexArray(global_quad_vao);
+    glDrawArrays(GL_TRIANGLES, 0, 6);
+    glBindVertexArray(0);
+    glEnable(GL_DEPTH_TEST);
+}
+
+int
+main(void)
+{
+    GLFWwindow *window;
+    Arena *arena;
+    State state;
+    Mesh *cube_mesh, *plane_mesh;
+    F64 time, last_time;
+    
+    glfwSetErrorCallback(error_callback);
+    
+    if (glfwInit() == GLFW_FALSE)
+        return(1);
+    
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_SAMPLES, 4);
+    window = glfwCreateWindow(global_screen_width, global_screen_height, "Shadow mapping", 0, 0);
+    if (!window)
+        goto error;
+    
+    glfwSetKeyCallback(window, glfw_key_callback);
+    glfwSetWindowSizeCallback(window, resize_callback);
+    
+    glfwMakeContextCurrent(window);
+    
+    if (glewInit() != GLEW_OK)
+        goto error;
+    
+    glEnable(GL_DEPTH_TEST);
+    // glEnable(GL_CULL_FACE);
+    
+    /* NOTE(pryazha): Init */
+    arena = arena_alloc(Megabytes(64));
+    
+    state.camera = (Camera){ v3f(0.0f, 1.0f, 3.0f), 90.0f, 0.1f, 100.0f };
+    light_pos = v3f(-2.0f, 4.0f, -2.0f);
+
+    /* NOTE(pryazha): Meshes */
+    Vertex plane_vertices[] = {
+        // positions            // normals         // texcoords
+        vertex(v3f(-25.0f, -0.5f,  25.0f),  v3f(0.0f, 1.0f, 0.0f),   v2f(0.0f,  0.0f)),
+        vertex(v3f(25.0f, -0.5f,  25.0f),  v3f(0.0f, 1.0f, 0.0f),  v2f(25.0f,  0.0f)),
+        vertex(v3f(-25.0f, -0.5f, -25.0f),  v3f(0.0f, 1.0f, 0.0f),   v2f(0.0f, 25.0f)),
+
+        vertex(v3f(25.0f, -0.5f,  25.0f),  v3f(0.0f, 1.0f, 0.0f),  v2f(25.0f,  0.0f)),
+        vertex(v3f(25.0f, -0.5f, -25.0f),  v3f(0.0f, 1.0f, 0.0f),  v2f(25.0f, 25.0f)),
+        vertex(v3f(-25.0f, -0.5f, -25.0f),  v3f(0.0f, 1.0f, 0.0f),   v2f(0.0f, 25.0f)),
+    };
+    U32 indices[] = { 0, 1, 2, 3, 4, 5 };
+    plane_mesh = mesh_init(arena, plane_vertices, ArrayCount(plane_vertices), indices, ArrayCount(indices));
+    cube_mesh = mesh_load_obj(arena, "../../data/models/cube.obj");
+    
+    F32 quad_vertices[] = {
+        -1.0f, -1.0f,  0.0f,   0.0f, 0.0f,
+         1.0f, -1.0f,  0.0f,   1.0f, 0.0f,
+         1.0f,  1.0f,  0.0f,   1.0f, 1.0f,
+        -1.0f, -1.0f,  0.0f,   0.0f, 0.0f,
+         1.0f,  1.0f,  0.0f,   1.0f, 1.0f,
+        -1.0f,  1.0f,  0.0f,   0.0f, 1.0f
+    };
+    
+    U32 vbo;    
+    glGenVertexArrays(1, &global_quad_vao);
+    glBindVertexArray(global_quad_vao);
+    glGenBuffers(1, &vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GL_STATIC_DRAW);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(F32), (void *)0);
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(F32), (void *)(3*sizeof(F32)));
+    glBindVertexArray(0);
+
+    /* NOTE(pryazha): Shaders */
+    global_debug_quad_shader = create_shader_program("shaders/debug_quad.vs",
+                                                     "shaders/debug_quad.fs");
+    global_simple_depth_shader = create_shader_program("shaders/simple_depth.vs",
+                                                       "shaders/simple_depth.fs");
+    global_shadow_shader = create_shader_program("shaders/shadow.vs", "shaders/shadow.fs");
+    global_color_shader = create_shader_program("shaders/color.vs", "shaders/color.fs");
+    
+    glUseProgram(global_shadow_shader);
+    shader_set_1i(global_shadow_shader, "diffuse_texture", 0);
+    shader_set_1i(global_shadow_shader, "shadow_map", 1);
+    glUseProgram(0);
+
+    global_wood_texture = load_texture_gamma("../../data/textures/wood.png", 1);
+
+    glGenFramebuffers(1, &global_depth_map_fbo);
+    glGenTextures(1, &global_depth_map);
+    glBindTexture(GL_TEXTURE_2D, global_depth_map);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, global_shadow_width,
+                 global_shadow_height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    glBindFramebuffer(GL_FRAMEBUFFER, global_depth_map_fbo);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
+                           global_depth_map, 0);
+    V4F border_color = v4f(1.0f, 1.0f, 1.0f, 1.0f);
+    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, (const F32 *)&border_color);
+    glDrawBuffer(GL_NONE);
+    glReadBuffer(GL_NONE);
+    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+        fprintf(stderr, "[ERROR]: Failed to complete depth map framebuffer.\n");
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    last_time = glfwGetTime();
+    
+    while (!glfwWindowShouldClose(window))
+    {
+        glfwPollEvents();
+        if (key_first_press(global_input.exit))
+            glfwSetWindowShouldClose(window, GLFW_TRUE);
+        update(&state, time);
+        render(&state, cube_mesh, plane_mesh);
+        glfwSwapBuffers(window);
+        
+        time = glfwGetTime();
+        state.dt = time-last_time;
+        last_time = time;
+#if 0
+        fprintf(stdout, "[INFO]: dt: %f\n", state.dt);
+#endif
+    }
+
+    glfwTerminate();
+    return(0);
+    
+    error:
+    glfwTerminate();
+    return(1);
+}