change

1 files changed, 383 insertions, 0 deletions

diff --git a/advanced_lighting/3.2.point_shadows/point_shadows.c b/advanced_lighting/3.2.point_shadows/point_shadows.c
new file mode 100644
index 0000000..0f60565
--- /dev/null
+++ b/advanced_lighting/3.2.point_shadows/point_shadows.c
@@ -0,0 +1,383 @@
+#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 Input global_input;
+static B32 first_mouse = 1;
+
+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
+cursor_pos_callback(GLFWwindow* window, double xpos, double ypos)
+{
+    if (first_mouse)
+    {
+        global_input.last_mouse_pos = v2f(xpos, ypos);
+        first_mouse = 0;
+    }
+    global_input.mouse_offset = v2f(global_input.mouse_offset.x+((F32)xpos-global_input.last_mouse_pos.x),
+                             global_input.mouse_offset.y+((F32)ypos-global_input.last_mouse_pos.y));
+    global_input.last_mouse_pos = v2f((F32)xpos, (F32)ypos);
+}
+
+
+void
+render_scene(U32 shader, Mesh *cube)
+{
+    MAT4 model;
+
+    model = mat4_identity();
+    model = mat4_make_scale(v3f(5.0f, 5.0f, 5.0f));
+    shader_set_mat4fv(shader, "model", model);
+    glDisable(GL_CULL_FACE);
+    shader_set_1i(shader, "reverse_normals", 1);
+    mesh_draw(cube);
+    shader_set_1i(shader, "reverse_normals", 0);
+    glEnable(GL_CULL_FACE);
+
+    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);
+}
+
+int
+main(void)
+{
+    GLFWwindow *window;
+    Arena *arena;
+    State state;
+    Mesh *cube;
+    F64 time, last_time;
+    V3F light_pos;
+    MAT4 shadow_transforms[6];
+    MAT4 proj, view;
+    
+    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, "Point shadows", 0, 0);
+    if (!window)
+        goto error;
+
+    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+    
+    glfwSetKeyCallback(window, glfw_key_callback);
+    glfwSetWindowSizeCallback(window, resize_callback);
+    glfwSetCursorPosCallback(window, cursor_pos_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){
+        .pos = v3f(0.0f, 1.0f, 3.0f),
+        .fovx = 100.0f,
+        .near = 0.1f,
+        .far = 100.0f,
+        .yaw = 0.0f,
+        .pitch = 0.0f
+    };
+    V3F camera_dp = v3f_zero();
+    /* light_pos = v3f(-2.0f, 4.0f, -2.0f); */
+    light_pos = v3f_zero();
+
+    /* NOTE(pryazha): Meshes */
+    cube = 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 quad_vao, vbo;
+    glGenVertexArrays(1, &quad_vao);
+    glBindVertexArray(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 */
+    U32 depth_shader = create_shader_program_geom("shaders/depth.vs",
+                                                  "shaders/depth.fs",
+                                                  "shaders/depth.gs");
+    U32 shadow_shader = create_shader_program("shaders/shadow.vs", "shaders/shadow.fs");
+    
+    glUseProgram(shadow_shader);
+    shader_set_1i(shadow_shader, "diffuse_texture", 0);
+    shader_set_1i(shadow_shader, "depth_cubemap", 1);
+    glUseProgram(0);
+
+    U32 wood_texture = load_texture_gamma("../../data/textures/wood.png", 0);
+
+    /* NOTE(pryazha): Depth framebuffer init */
+    U32 depth_cubemap_fbo, depth_cubemap;
+    U32 shadow_width = 1024, shadow_height = 1024;
+    glGenFramebuffers(1, &depth_cubemap_fbo);
+    glGenTextures(1, &depth_cubemap);
+    glBindTexture(GL_TEXTURE_CUBE_MAP, depth_cubemap);
+    for (U32 cubemap_side = 0; cubemap_side < 6; ++cubemap_side)
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+cubemap_side, 0, GL_DEPTH_COMPONENT,
+                     shadow_width, shadow_height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_BORDER);
+    glBindFramebuffer(GL_FRAMEBUFFER, depth_cubemap_fbo);
+    glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_cubemap, 0);
+    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);
+
+        /* NOTE(pryazha): For now it's easier to write all of the logic in the main loop */
+        /* NOTE(pryazha): Update */
+        F32 x, y, z, angular_speed, radius;
+        V3F camera_dv;
+
+        camera_dv = get_dv_camera_first_person(&global_input, &state.camera,
+                                               1.0f, state.dt);
+        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);
+
+        F32 sensitivity = 0.1f;
+        global_input.mouse_offset = v2f_scalef(global_input.mouse_offset, sensitivity);
+        state.camera.yaw += global_input.mouse_offset.x;
+        state.camera.pitch += global_input.mouse_offset.y;
+        if (state.camera.pitch > 89.0f)
+            state.camera.pitch = 89.0f;
+        if (state.camera.pitch < -89.0f)
+            state.camera.pitch = -89.0f;
+
+        input_update_last_state(&global_input);
+
+        angular_speed = 1.0f;
+        radius = 4.0f;
+        x = f32_sin(time*angular_speed)*radius;
+        y = f32_sin(time*angular_speed)*f32_sin(time*angular_speed)*radius;
+        z = f32_cos(time*angular_speed)*radius;
+
+        light_pos = v3f(x, y, z);
+
+        /* NOTE(pryazha): Render */
+
+        /* NOTE(pryazha): Render the depth cubemap */
+        F32 fovx, aspect, near, far;
+        fovx = 90.0f;
+        aspect = (F32)shadow_width/(F32)shadow_height;
+        near = 1.0f;
+        far = 25.0f;
+        proj = perspective(fovx, aspect, near, far);
+        shadow_transforms[0] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 1.0f,  0.0f,  0.0f)), v3f(0.0f, -1.0f,  0.0f))); /* right */
+        shadow_transforms[1] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f(-1.0f,  0.0f,  0.0f)), v3f(0.0f, -1.0f,  0.0f))); /* left */
+        shadow_transforms[2] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f,  1.0f,  0.0f)), v3f(0.0f,  0.0f,  1.0f))); /* top */
+        shadow_transforms[3] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f, -1.0f,  0.0f)), v3f(0.0f,  0.0f, -1.0f))); /* bottom */
+        shadow_transforms[4] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f,  0.0f,  1.0f)), v3f(0.0f, -1.0f,  0.0f))); /* near */
+        shadow_transforms[5] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f,  0.0f, -1.0f)), v3f(0.0f, -1.0f,  0.0f))); /* far */
+        glViewport(0, 0, shadow_width, shadow_height);
+        glBindFramebuffer(GL_FRAMEBUFFER, depth_cubemap_fbo);
+        glClear(GL_DEPTH_BUFFER_BIT);
+        glUseProgram(depth_shader);
+        shader_set_1f(depth_shader, "far", far);
+        shader_set_3fv(depth_shader, "light_pos", light_pos);
+        for (U32 i = 0; i < 6; ++i)
+        {
+            char uniform_name[256];
+            snprintf(uniform_name, 256, "shadow_transforms[%d]", i);
+            shader_set_mat4fv(depth_shader, uniform_name, shadow_transforms[i]);
+        }
+        render_scene(depth_shader, cube);
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+        /* NOTE(pryazha): Render the scene as normal */
+        glViewport(0, 0, global_screen_width, global_screen_height);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        glUseProgram(shadow_shader);
+
+        aspect = (F32)global_screen_width/(F32)global_screen_height;
+        proj = perspective(state.camera.fovx, aspect, state.camera.near, state.camera.far);
+        view = get_view_matrix(&state.camera);
+
+        shader_set_mat4fv(shadow_shader, "projection", proj); 
+        shader_set_mat4fv(shadow_shader, "view", view);
+        shader_set_3fv(shadow_shader, "light_pos", light_pos);
+        shader_set_3fv(shadow_shader, "view_pos", state.camera.pos);
+        shader_set_1f(shadow_shader, "far", far);
+
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, wood_texture);
+        glActiveTexture(GL_TEXTURE1);
+        glBindTexture(GL_TEXTURE_CUBE_MAP, depth_cubemap);
+        render_scene(shadow_shader, cube);
+
+        glfwSwapBuffers(window);
+        
+        time = glfwGetTime();
+        state.dt = time-last_time;
+        last_time = time;
+    }
+
+    glfwTerminate();
+    return(0);
+    
+    error:
+    glfwTerminate();
+    return(1);
+}