quite a lot of changes that I, of course, are not going to describe;)

14 files changed, 424 insertions, 464 deletions

diff --git a/advanced_lighting/4.normal_mapping/normal_mapping b/advanced_lighting/4.normal_mapping/normal_mapping
index 6d33c26..1fbb26b 100755
--- a/advanced_lighting/4.normal_mapping/normal_mapping
+++ b/advanced_lighting/4.normal_mapping/normal_mapping
diff --git a/advanced_lighting/4.normal_mapping/normal_mapping.c b/advanced_lighting/4.normal_mapping/normal_mapping.c
index 1d65b49..980f4a0 100644
--- a/advanced_lighting/4.normal_mapping/normal_mapping.c
+++ b/advanced_lighting/4.normal_mapping/normal_mapping.c
@@ -1,288 +1,251 @@
-#include "pwyazh.h"
-
 #include "GL/glew.h"
 #include "GLFW/glfw3.h"
 
+#include "pwyazh.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
-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
-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)
+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);
-    
-    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();
-
-        /* NOTE(pryazha): For now it's easier to write all of the logic in the main loop */
-
-        /* NOTE(pryazha): Update */
-        process_glfw_keyboard(window, &global_input);
-
-        if (key_first_press(global_input.exit))
-            glfwSetWindowShouldClose(window, GLFW_TRUE);
-
-        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)*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);
+	GLFWwindow *window;
+	State state;
+	Input input;
+	F64 time, last_time;
+	V3F light_pos;
+	MAT4 proj, view, model;
+	F32 aspect, angle = 0.0f;
+	Mesh *cube = 0;
+	Arena *arena = 0;
+	S32 width, height;
+
+	glfwSetErrorCallback(error_callback);
+
+	if (glfwInit() == GLFW_FALSE)
+		return(1);
+
+	width = 800;
+	height = 600;
+
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+	glfwWindowHint(GLFW_SAMPLES, 4);
+	window = glfwCreateWindow(width, height, "Point shadows", 0, 0);
+	if (!window)
+		goto error;
+
+	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+	glfwMakeContextCurrent(window);
+
+	if (glewInit() != GLEW_OK)
+		goto error;
+
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_CULL_FACE);
+
+	/* NOTE(pryazha): Init */
+	arena = arena_alloc(Kilobytes(4));
+
+	state.camera = (Camera){ v3f(0.0f, 1.0f, 3.0f), 100.0f, 0.1f, 100.0f, 0.0f, 0.0f };
+	V3F camera_dp = v3f_zero();
+	F32 x, y, z;
+
+	/* NOTE(pryazha): Meshes */
+	cube = mesh_load_obj(arena, "../../data/models/cube.obj");
+
+	/* Positions */
+	V3F p1 = v3f(-1.0f, 1.0f, 0.0f);
+	V3F p2 = v3f(-1.0f, -1.0f, 0.0f);
+	V3F p3 = v3f(1.0f, -1.0f, 0.0f);
+	V3F p4 = v3f(1.0f, 1.0f, 0.0f);
+	/* Texture ccoordinates */
+	V2F uv1 = v2f(0.0f, 1.0f);
+	V2F uv2 = v2f(0.0f, 0.0f);
+	V2F uv3 = v2f(1.0f, 0.0f);
+	V2F uv4 = v2f(1.0f, 1.0f);
+	/* Normal vector */
+	V3F nm = v3f(0.0f, 0.0f, 1.0f);
+
+	V3F edge1, edge2;
+	V2F duv1, duv2;
+	F32 f;
+	V3F t1, bit1, t2, bit2;
+
+	edge1 = v3f_sub(p2, p1);
+	edge2 = v3f_sub(p3, p1);
+	duv1 = v2f_sub(uv2, uv1);
+	duv2 = v2f_sub(uv3, uv1);
+
+	f = 1.0f/(duv1.x*duv2.y-duv2.x*duv1.y);
+
+	t1.x = f*(duv2.y*edge1.x-duv1.y*edge2.x);
+	t1.y = f*(duv2.y*edge1.y-duv1.y*edge2.y);
+	t1.z = f*(duv2.y*edge1.z-duv1.y*edge2.z);
+
+	bit1.x = f*(-duv2.x*edge1.x+duv1.x*edge2.x);
+	bit1.y = f*(-duv2.x*edge1.y+duv1.x*edge2.y);
+	bit1.z = f*(-duv2.x*edge1.z+duv1.x*edge2.z);
+
+	edge1 = v3f_sub(p3, p1);
+	edge2 = v3f_sub(p4, p1);
+	duv1 = v2f_sub(uv3, uv1);
+	duv2 = v2f_sub(uv4, uv1);
+
+	f = 1.0f/(duv1.x*duv2.y-duv2.x*duv1.y);
+
+	t2.x = f*(duv2.y*edge1.x-duv1.y*edge2.x);
+	t2.y = f*(duv2.y*edge1.y-duv1.y*edge2.y);
+	t2.z = f*(duv2.y*edge1.z-duv1.y*edge2.z);
+
+	bit2.x = f*(-duv2.x*edge1.x+duv1.x*edge2.x);
+	bit2.y = f*(-duv2.x*edge1.y+duv1.x*edge2.y);
+	bit2.z = f*(-duv2.x*edge1.z+duv1.x*edge2.z);
+
+	F32 quad_vertices[] = {
+		p1.x, p1.y, p1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, t1.x, t1.y, t1.z, bit1.x, bit1.y, bit1.z,
+		p2.x, p2.y, p2.z, nm.x, nm.y, nm.z, uv2.x, uv2.y, t1.x, t1.y, t1.z, bit1.x, bit1.y, bit1.z,
+		p3.x, p3.y, p3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, t1.x, t1.y, t1.z, bit1.x, bit1.y, bit1.z,
+
+		p1.x, p1.y, p1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, t2.x, t2.y, t2.z, bit2.x, bit2.y, bit2.z,
+		p3.x, p3.y, p3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, t2.x, t2.y, t2.z, bit2.x, bit2.y, bit2.z,
+		p4.x, p4.y, p4.z, nm.x, nm.y, nm.z, uv4.x, uv4.y, t2.x, t2.y, t2.z, bit2.x, bit2.y, bit2.z
+	};
+	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, 14*sizeof(F32), (void *)0);
+	glEnableVertexAttribArray(1);
+	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14*sizeof(F32), (void *)(3*sizeof(F32)));
+	glEnableVertexAttribArray(2);
+	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14*sizeof(F32), (void *)(6*sizeof(F32)));
+	glEnableVertexAttribArray(3);
+	glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14*sizeof(F32), (void *)(8*sizeof(F32)));
+	glEnableVertexAttribArray(4);
+	glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14*sizeof(F32), (void *)(11*sizeof(F32)));
+	glBindVertexArray(0);
+
+	/* NOTE(pryazha): Shaders */
+	U32 normal_map_shader = create_shader_program("shaders/normal_map.vert",
+						      "shaders/normal_map.frag");
+	U32 normals_debug_shader = create_shader_program_geom("shaders/normals_debug.vert",
+							      "shaders/normals_debug.frag",
+							      "shaders/normals_debug.geom");
+	U32 color_shader = create_shader_program("shaders/color.vert",
+						 "shaders/color.frag");
+
+	glUseProgram(normal_map_shader);
+	shader_set_1i(normal_map_shader, "diffuse_texture", 0);
+	shader_set_1i(normal_map_shader, "normal_map", 1);
+	glUseProgram(0);
+
+	U32 brickwall_diffuse_texture = load_texture("../../data/textures/brickwall.jpg");
+	U32 brickwall_normal_texture = load_texture("../../data/textures/brickwall_normal.jpg");
+
+	last_time = glfwGetTime();
+
+	while (!glfwWindowShouldClose(window)) {
+		glfwPollEvents();
+
+		/* NOTE(pryazha): For now it's easier to write all of the logic in the main loop */
+
+		/* NOTE(pryazha): Update */
+		glfwGetFramebufferSize(window, &width, &height);
+		process_glfw_keyboard(window, &input);
+		process_glfw_mouse_pos(window, &input);
+
+		if (key_first_press(input.exit))
+			glfwSetWindowShouldClose(window, GLFW_TRUE);
+
+		F32 speed = 2.0f;
+		V3F dv = get_dv_camera_first_person(&input, &state.camera,
+						    speed, state.dt);
+		if (key_is_pressed(input.action_up))
+			dv = v3f_scalef(dv, 3.0f);
+		camera_dp = v3f_add(camera_dp, dv);
+		camera_dp = v3f_scalef(camera_dp, 0.8f);
+		state.camera.pos = v3f_add(state.camera.pos, camera_dp);
+
+		F32 sensitivity = 0.1f;
+		input.mouse_offset = v2f_scalef(input.mouse_offset, sensitivity);
+		state.camera.yaw += input.mouse_offset.x;
+		state.camera.pitch += 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(&input);
+
+		angle += 40.0f*state.dt;
+
+		x = f32_cos((F32)time);
+		y = f32_sin((F32)time);
+		z = 1.0f;
+		light_pos = v3f(x, y, z);
+
+		/* NOTE(pryazha): Render */
+		aspect = (F32)width/(F32)height;
+		proj = perspective(state.camera.fovx, aspect,
+				   state.camera.near, state.camera.far);
+		view = get_view_matrix(&state.camera);
+
+		glViewport(0, 0, width, height);
+		glClearColor(0.15f, 0.15f, 0.15f, 1.0f);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		glUseProgram(normal_map_shader);
+		shader_set_mat4fv(normal_map_shader, "proj", proj); 
+		shader_set_mat4fv(normal_map_shader, "view", view);
+		shader_set_3fv(normal_map_shader, "light_pos", light_pos);
+		shader_set_3fv(normal_map_shader, "view_pos", state.camera.pos);
+		model = mat4_rotate_angles(mat4_identity(), v3f(angle, angle, angle));
+		shader_set_mat4fv(normal_map_shader, "model", model);
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, brickwall_diffuse_texture);
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D, brickwall_normal_texture);
+		glBindVertexArray(quad_vao);
+		glDrawArrays(GL_TRIANGLES, 0, 6);
+		glBindVertexArray(0);
+		glUseProgram(0);
+
+		glUseProgram(color_shader);
+		shader_set_mat4fv(color_shader, "proj", proj); 
+		shader_set_mat4fv(color_shader, "view", view);
+		model = mat4_make_scale(v3f(0.05f, 0.05f, 0.05f));
+		model = mat4_translate(model, light_pos);
+		shader_set_mat4fv(color_shader, "model", model);
+		mesh_draw(cube);
+		glUseProgram(0);
+
+		glUseProgram(normals_debug_shader);
+		shader_set_mat4fv(normals_debug_shader, "proj", proj); 
+		shader_set_mat4fv(normals_debug_shader, "view", view);
+		model = mat4_rotate_angles(mat4_identity(), v3f(angle, angle, angle));
+		shader_set_mat4fv(normals_debug_shader, "model", model);
+		glBindVertexArray(quad_vao);
+		glDrawArrays(GL_TRIANGLES, 0, 6);
+		glBindVertexArray(0);
+		glUseProgram(0);
+
+		glfwSwapBuffers(window);
+
+		time = glfwGetTime();
+		state.dt = time-last_time;
+		last_time = time;
+	}
+
+	arena_release(arena);
+	glfwTerminate();
+	return(0);
+
+error:
+	arena_release(arena);
+	glfwTerminate();
+	return(1);
 }
diff --git a/advanced_lighting/4.normal_mapping/shaders/color.frag b/advanced_lighting/4.normal_mapping/shaders/color.frag
new file mode 100644
index 0000000..c01da99
--- /dev/null
+++ b/advanced_lighting/4.normal_mapping/shaders/color.frag
@@ -0,0 +1,8 @@
+#version 330 core
+
+out vec4 frag_color;
+
+void main(void)
+{
+    frag_color = vec4(1.0);
+}
diff --git a/advanced_lighting/4.normal_mapping/shaders/color.vert b/advanced_lighting/4.normal_mapping/shaders/color.vert
new file mode 100644
index 0000000..a8b1247
--- /dev/null
+++ b/advanced_lighting/4.normal_mapping/shaders/color.vert
@@ -0,0 +1,11 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+
+uniform mat4 proj;
+uniform mat4 view;
+uniform mat4 model;
+
+void main(void)
+{
+    gl_Position = proj*view*model*vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/4.normal_mapping/shaders/depth.fs b/advanced_lighting/4.normal_mapping/shaders/depth.fs
deleted file mode 100644
index 88fb9e6..0000000
--- a/advanced_lighting/4.normal_mapping/shaders/depth.fs
+++ /dev/null
@@ -1,14 +0,0 @@
-#version 330 core
-
-in vec4 frag_pos;
-
-uniform vec3 light_pos;
-uniform float far;
-
-void
-main(void)
-{
-    float light_distance = length(frag_pos.xyz-light_pos);
-    light_distance = light_distance/far;
-    gl_FragDepth = light_distance;
-}
diff --git a/advanced_lighting/4.normal_mapping/shaders/depth.gs b/advanced_lighting/4.normal_mapping/shaders/depth.gs
deleted file mode 100644
index 638e2b9..0000000
--- a/advanced_lighting/4.normal_mapping/shaders/depth.gs
+++ /dev/null
@@ -1,27 +0,0 @@
-#version 330 core
-layout(triangles) in;
-layout(triangle_strip, max_vertices=18) out;
-
-uniform mat4 shadow_transforms[6];
-
-out vec4 frag_pos;
-
-void
-main(void)
-{
-    for (int face = 0;
-         face < 6;
-         ++face)
-    {
-        gl_Layer = face;
-        for (int vertex = 0;
-             vertex < 3;
-             ++vertex)
-        {
-            frag_pos = gl_in[vertex].gl_Position;
-            gl_Position = shadow_transforms[face]*frag_pos;
-            EmitVertex();
-        }
-        EndPrimitive();
-    }
-}
diff --git a/advanced_lighting/4.normal_mapping/shaders/depth.vs b/advanced_lighting/4.normal_mapping/shaders/depth.vs
deleted file mode 100644
index 37a3484..0000000
--- a/advanced_lighting/4.normal_mapping/shaders/depth.vs
+++ /dev/null
@@ -1,10 +0,0 @@
-#version 330 core
-layout(location = 0) in vec3 apos;
-
-uniform mat4 model;
-
-void
-main(void)
-{
-    gl_Position = model*vec4(apos, 1.0);
-}
diff --git a/advanced_lighting/4.normal_mapping/shaders/normal_map.frag b/advanced_lighting/4.normal_mapping/shaders/normal_map.frag
new file mode 100644
index 0000000..964d6f8
--- /dev/null
+++ b/advanced_lighting/4.normal_mapping/shaders/normal_map.frag
@@ -0,0 +1,51 @@
+#version 330 core
+
+in VS_OUT {
+    /* mat3 TBN; */
+    vec3 frag_pos;
+    vec3 tangent_light_pos;
+    vec3 tangent_view_pos;
+    vec3 tangent_frag_pos;
+    vec2 tex_coords;
+} fs_in;
+
+out vec4 frag_color;
+
+/* uniform vec3 light_pos; */
+/* uniform vec3 view_pos; */
+
+uniform sampler2D diffuse_texture;
+uniform sampler2D normal_map;
+
+void main(void)
+{
+    vec3 color = vec3(texture(diffuse_texture, fs_in.tex_coords));
+    vec3 normal = vec3(texture(normal_map, fs_in.tex_coords));
+    normal = normalize((normal*2.0)-1.0);
+    /*
+    normal = normalize(fs_in.TBN*normal);
+
+    vec3 light_dir = fs_in.TBN * normalize(light_pos - fs_in.frag_pos);
+    vec3 view_dir = fs_in.TBN * normalize(view_pos - fs_in.frag_pos);
+    */
+
+    vec3 light_color = vec3(1.0);
+
+    float ambient = 0.01;
+
+    /* vec3 light_dir = normalize(light_pos-fs_in.frag_pos); */
+    vec3 light_dir = normalize(fs_in.tangent_light_pos - fs_in.tangent_frag_pos);
+    float diff = max(dot(light_dir, normal), 0.0);
+    vec3 diffuse = diff*light_color;
+
+    /* vec3 view_dir = normalize(view_pos-fs_in.frag_pos); */
+    vec3 view_dir = normalize(fs_in.tangent_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);
+    float spec_strength = 1.0;
+    vec3 specular = spec_strength*spec*light_color;
+
+    vec3 result = (ambient+diffuse+specular)*color;
+
+    frag_color = vec4(result, 1.0);
+}
diff --git a/advanced_lighting/4.normal_mapping/shaders/normal_map.vert b/advanced_lighting/4.normal_mapping/shaders/normal_map.vert
new file mode 100644
index 0000000..3b089b5
--- /dev/null
+++ b/advanced_lighting/4.normal_mapping/shaders/normal_map.vert
@@ -0,0 +1,36 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+layout(location = 1) in vec3 anormal;
+layout(location = 2) in vec2 atex_coords;
+layout(location = 3) in vec3 atangent;
+layout(location = 4) in vec3 abitangent;
+
+out VS_OUT {
+    /* mat3 TBN; */
+    vec3 frag_pos;
+    vec3 tangent_light_pos;
+    vec3 tangent_view_pos;
+    vec3 tangent_frag_pos;
+    vec2 tex_coords;
+} vs_out;
+
+uniform mat4 proj;
+uniform mat4 view;
+uniform mat4 model;
+
+uniform vec3 light_pos;
+uniform vec3 view_pos;
+
+void main(void)
+{
+    vs_out.frag_pos = vec3(model * vec4(apos, 1.0));
+    vs_out.tex_coords = atex_coords;
+    vec3 T = normalize(vec3(model * vec4(atangent, 0.0)));
+    vec3 B = normalize(vec3(model * vec4(abitangent, 0.0)));
+    vec3 N = normalize(vec3(model * vec4(anormal, 0.0)));
+    mat3 TBN = transpose(mat3(T, B, N));
+    vs_out.tangent_light_pos = TBN * light_pos;
+    vs_out.tangent_view_pos = TBN * view_pos;
+    vs_out.tangent_frag_pos = TBN * vec3(model * vec4(apos, 0.0));
+    gl_Position = proj * view * vec4(vs_out.frag_pos, 1.0);
+}
diff --git a/advanced_lighting/4.normal_mapping/shaders/normals_debug.frag b/advanced_lighting/4.normal_mapping/shaders/normals_debug.frag
new file mode 100644
index 0000000..04dadd4
--- /dev/null
+++ b/advanced_lighting/4.normal_mapping/shaders/normals_debug.frag
@@ -0,0 +1,10 @@
+#version 330 core
+
+in vec3 vcolor;
+
+out vec4 frag_color;
+
+void main(void)
+{
+    frag_color = vec4(vcolor, 1.0);
+}
diff --git a/advanced_lighting/4.normal_mapping/shaders/normals_debug.geom b/advanced_lighting/4.normal_mapping/shaders/normals_debug.geom
new file mode 100644
index 0000000..666c08a
--- /dev/null
+++ b/advanced_lighting/4.normal_mapping/shaders/normals_debug.geom
@@ -0,0 +1,44 @@
+#version 330 core
+layout(triangles) in;
+layout(line_strip, max_vertices=18) out;
+
+in VS_OUT {
+    vec4 tangent;
+    vec4 bitangent;
+    vec4 normal;
+} gs_in[];
+
+out vec3 vcolor;
+
+uniform mat4 proj;
+
+void gen_normals(int index)
+{
+    vcolor = vec3(1.0, 0.0, 0.0);
+    gl_Position = proj*(gl_in[index].gl_Position);
+    EmitVertex();
+    gl_Position = proj*(gl_in[index].gl_Position+0.5*gs_in[index].tangent);
+    EmitVertex();
+    EndPrimitive();
+
+    vcolor = vec3(0.0, 0.0, 1.0);
+    gl_Position = proj*(gl_in[index].gl_Position);
+    EmitVertex();
+    gl_Position = proj*(gl_in[index].gl_Position+0.5*gs_in[index].bitangent);
+    EmitVertex();
+    EndPrimitive();
+
+    vcolor = vec3(0.0, 1.0, 0.0);
+    gl_Position = proj*(gl_in[index].gl_Position);
+    EmitVertex();
+    gl_Position = proj*(gl_in[index].gl_Position+0.5*gs_in[index].normal);
+    EmitVertex();
+    EndPrimitive();
+}
+
+void main(void)
+{
+    gen_normals(0);
+    gen_normals(1);
+    gen_normals(2);
+}
diff --git a/advanced_lighting/4.normal_mapping/shaders/normals_debug.vert b/advanced_lighting/4.normal_mapping/shaders/normals_debug.vert
new file mode 100644
index 0000000..d3eed77
--- /dev/null
+++ b/advanced_lighting/4.normal_mapping/shaders/normals_debug.vert
@@ -0,0 +1,22 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+layout(location = 1) in vec3 anormal;
+layout(location = 3) in vec3 atangent;
+layout(location = 4) in vec3 abitangent;
+
+out VS_OUT {
+    vec4 tangent;
+    vec4 bitangent;
+    vec4 normal;
+} vs_out;
+
+uniform mat4 view;
+uniform mat4 model;
+
+void main(void)
+{
+    vs_out.tangent = view*model*vec4(normalize(atangent), 0.0);
+    vs_out.bitangent = view*model*vec4(normalize(abitangent), 0.0);
+    vs_out.normal = view*model*vec4(normalize(anormal), 0.0);
+    gl_Position = view*model*vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/4.normal_mapping/shaders/shadow.fs b/advanced_lighting/4.normal_mapping/shaders/shadow.fs
deleted file mode 100644
index 6a3a8b0..0000000
--- a/advanced_lighting/4.normal_mapping/shaders/shadow.fs
+++ /dev/null
@@ -1,105 +0,0 @@
-#version 330 core
-
-in VS_OUT {
-    vec3 frag_pos;
-    vec3 normal;
-    vec2 tex_coords;
-} fs_in;
-
-out vec4 frag_color;
-
-uniform vec3 light_pos;
-uniform vec3 view_pos;
-uniform float far;
-
-uniform sampler2D diffuse_texture;
-uniform samplerCube depth_cubemap;
-
-vec3 grid_sampling_disk[20] = vec3[]
-(
-   vec3(1, 1,  1), vec3( 1, -1,  1), vec3(-1, -1,  1), vec3(-1, 1,  1), 
-   vec3(1, 1, -1), vec3( 1, -1, -1), vec3(-1, -1, -1), vec3(-1, 1, -1),
-   vec3(1, 1,  0), vec3( 1, -1,  0), vec3(-1, -1,  0), vec3(-1, 1,  0),
-   vec3(1, 0,  1), vec3(-1,  0,  1), vec3( 1,  0, -1), vec3(-1, 0, -1),
-   vec3(0, 1,  1), vec3( 0, -1,  1), vec3( 0, -1, -1), vec3( 0, 1, -1)
-);
-
-float
-calculate_shadow(vec3 frag_pos)
-{
-    vec3 frag_to_light = frag_pos-light_pos;
-    /* float closest_depth = texture(depth_cubemap, frag_to_light).r; */
-    /* closest_depth *= far; */
-    float current_depth = length(frag_to_light);
-    /* float bias = 0.05; */
-    /* float shadow = current_depth-bias > closest_depth ? 1.0 : 0.0; */
-    /* NOTE(pryazha): Display depth value for debugging */
-    /* frag_color = vec4(vec3(closest_depth/far), 1.0); */
-    /*
-    float shadow = 0.0;
-    float offset = 0.1;
-    float samples = 4.0;
-    for (float x = -offset;
-         x < offset;
-         x += offset/(samples*0.5))
-    {
-        for (float y = -offset;
-             y < offset;
-             y += offset/(samples*0.5))
-        {
-            for (float z = -offset;
-                 z < offset;
-                 z += offset/(samples*0.5))
-            {
-                float closest_depth = texture(depth_cubemap, frag_to_light+vec3(x, y, z)).r;
-                closest_depth *= far;
-                if (current_depth-bias > closest_depth)
-                    shadow += 1.0;
-            }
-        }
-    }
-    shadow /= (samples*samples*samples);
-    */
-
-    float shadow = 0.0;
-    float bias = 0.15;
-    int samples = 20;
-    float view_distance = length(view_pos-frag_pos);
-    float disk_radius = (1.0+(view_distance/far))/25.0;
-    for (int sample = 0;
-         sample < samples;
-         ++sample)
-    {
-        float closest_depth = texture(depth_cubemap, frag_to_light+
-                                      grid_sampling_disk[sample]*disk_radius).r;
-        closest_depth *= far;
-        if (current_depth-bias > closest_depth)
-            shadow += 1.0;
-    }
-    shadow /= float(samples);
-    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.5);
-
-    vec3 ambient = 0.5*light_color;
-    
-    vec3 light_dir = normalize(light_pos-fs_in.frag_pos);
-    float diff = max(dot(light_dir, normal), 0.0);
-    vec3 diffuse = diff*light_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*light_color;
-
-    float shadow = calculate_shadow(fs_in.frag_pos);
-    vec3 lighting = (ambient+(1.0-shadow)*(diffuse+specular))*color;
-
-    frag_color = vec4(lighting, 1.0);
-}
diff --git a/advanced_lighting/4.normal_mapping/shaders/shadow.vs b/advanced_lighting/4.normal_mapping/shaders/shadow.vs
deleted file mode 100644
index ac8ee4f..0000000
--- a/advanced_lighting/4.normal_mapping/shaders/shadow.vs
+++ /dev/null
@@ -1,29 +0,0 @@
-#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 {
-    vec3 frag_pos;
-    vec3 normal;
-    vec2 tex_coords;
-} vs_out;
-
-uniform mat4 projection;
-uniform mat4 view;
-uniform mat4 model;
-
-uniform bool reverse_normals;
-
-void
-main(void)
-{
-    vs_out.frag_pos = vec3(model*vec4(apos, 1.0));
-    if (reverse_normals)
-        vs_out.normal = mat3(transpose(inverse(model)))*(-1.0*anormal);
-    else
-        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);
-}