Add reflective and refractive models

shaders/frag.glsl

@@ -53,7 +53,7 @@ vec3 calc_spot_light(SpotLight light, vec3 normal, vec3 frag_position, vec3 view
 
 void main() {
   vec3  normal         = normalize(vert_normal);
-  vec3  view_direction = normalize(camera_position - frag_position);
+  vec3  view_direction = normalize(frag_position - camera_position);
 
   vec3 result = calc_dir_light(directional_light, normal, view_direction);
 

shaders/reflective_frag.glsl

@@ -0,0 +1,16 @@
+#version 330 core
+
+in vec3 vert_normal;
+in vec3 frag_position;
+
+uniform vec3 camera_position;
+uniform samplerCube cubemap;
+
+out vec4 color;
+
+void main() {
+  vec3 view_direction    = normalize(frag_position - camera_position);
+  vec3 reflect_direction = reflect(view_direction, normalize(vert_normal));
+
+  color = vec4(texture(cubemap, reflect_direction).rgb, 1.0);
+}

shaders/refractive_frag.glsl

@@ -0,0 +1,19 @@
+#version 330 core
+
+#define AIR_IOR 1.0
+#define GLASS_IOR 1.52
+
+in vec3 vert_normal;
+in vec3 frag_position;
+
+uniform vec3 camera_position;
+uniform samplerCube cubemap;
+
+out vec4 color;
+
+void main() {
+  vec3 view_direction    = normalize(frag_position - camera_position);
+  vec3 refract_direction = refract(view_direction, normalize(vert_normal), AIR_IOR / GLASS_IOR);
+
+  color = vec4(texture(cubemap, refract_direction).rgb, 1.0);
+}

src/main.cc

@@ -267,20 +267,22 @@ int main() {
 
   Mesh screen = {screen_vertices, screen_indices, {}};
 
-  Shader main_shader     {"shaders/vert.glsl",    "shaders/frag.glsl"};
+  Shader main_shader       {"shaders/vert.glsl",    "shaders/frag.glsl"};
-  Shader light_shader    {"shaders/vert.glsl",    "shaders/light_frag.glsl"};
+  Shader light_shader      {"shaders/vert.glsl",    "shaders/light_frag.glsl"};
-  Shader skybox_shader   {"shaders/sb_vert.glsl", "shaders/sb_frag.glsl"};
+  Shader skybox_shader     {"shaders/sb_vert.glsl", "shaders/sb_frag.glsl"};
-  Shader post_processing {"shaders/pp_vert.glsl", "shaders/pp_frag.glsl"};
+  Shader reflective_shader {"shaders/vert.glsl",    "shaders/reflective_frag.glsl"};
+  Shader refractive_shader {"shaders/vert.glsl",    "shaders/refractive_frag.glsl"};
+  Shader post_processing   {"shaders/pp_vert.glsl", "shaders/pp_frag.glsl"};
 
   const float camera_speed   = 25.0f;
-  glm::vec3 camera_position  = glm::vec3(-2.0f, 0.0f, 6.0f);
+  glm::vec3 camera_position  = glm::vec3(-2.5f, 0.0f, 8.0f);
   glm::vec3 camera_forward   = glm::vec3(0.0f);
   glm::vec3 world_up         = glm::vec3(0.0f, 1.0f, 0.0f);
   glm::vec3 light_ambient    = glm::vec3(0.2f, 0.2f, 0.2f);
   glm::vec3 light_diffuse    = glm::vec3(0.75f, 0.75f, 0.75f);
   glm::vec3 light_specular   = glm::vec3(1.0f, 1.0f, 1.0f);
 
-  float yaw   = -70.0f;
+  float yaw   = -75.0f;
   float pitch =   0.0f;
 
   glm::mat4 model      = glm::mat4(1.0f);
@@ -293,6 +295,8 @@ int main() {
 
   light_shader.set_mat4("projection", projection);
   skybox_shader.set_mat4("projection", projection);
+  reflective_shader.set_mat4("projection", projection);
+  refractive_shader.set_mat4("projection", projection);
 
   std::vector<glm::vec3> point_light_positions = {
     glm::vec3( 0.7f,  0.2f,  2.0f),
@@ -445,6 +449,10 @@ int main() {
     main_shader.set_float("spot_light.outer_cutoff", glm::cos(glm::radians(17.5)));
     main_shader.set_mat4("view", view);
     light_shader.set_mat4("view", view);
+    reflective_shader.set_vec3("camera_position", camera_position);
+    reflective_shader.set_mat4("view", view);
+    refractive_shader.set_vec3("camera_position", camera_position);
+    refractive_shader.set_mat4("view", view);
     skybox_shader.set_mat4("view", glm::mat4(glm::mat3(view)));
 
     // Main render pass
@@ -464,15 +472,29 @@ int main() {
     main_shader.set_mat3("normal_mat", normal_mat);
     suzanne.draw(main_shader);
 
-    // Draw light source
+    model = glm::translate(glm::mat4(1.0f), glm::vec3(3.0f, 0.0f, 0.0f));
-    for (int i = 0; i < point_light_positions.size(); ++i) {
+    normal_mat = glm::transpose(glm::inverse(model));
-      model = glm::translate(glm::mat4(1.0f), point_light_positions[i]);
+    reflective_shader.set_mat4("model", model);
-      model = glm::scale(model, glm::vec3(0.2f));
+    reflective_shader.set_mat3("normal_mat", normal_mat);
-      light_shader.activate();
+    suzanne.draw(reflective_shader);
-      light_shader.set_mat4("model", model);
+
-      light_shader.set_vec3("light_diffuse", light_diffuse);
+    glDisable(GL_CULL_FACE);
-      light.draw(light_shader);
+    model = glm::translate(glm::mat4(1.0f), glm::vec3(-3.0f, 0.0f, 0.0f));
-    }
+    normal_mat = glm::transpose(glm::inverse(model));
+    refractive_shader.set_mat4("model", model);
+    refractive_shader.set_mat3("normal_mat", normal_mat);
+    suzanne.draw(refractive_shader);
+    glEnable(GL_CULL_FACE);
+
+    // Draw point lights
+    // for (int i = 0; i < point_light_positions.size(); ++i) {
+    //   model = glm::translate(glm::mat4(1.0f), point_light_positions[i]);
+    //   model = glm::scale(model, glm::vec3(0.2f));
+    //   light_shader.activate();
+    //   light_shader.set_mat4("model", model);
+    //   light_shader.set_vec3("light_diffuse", light_diffuse);
+    //   light.draw(light_shader);
+    // }
 
     // Draw skybox
     glDisable(GL_CULL_FACE);
@@ -738,6 +760,8 @@ void Mesh::draw(Shader &shader) {
 }
 
 void Model::draw(Shader &shader) {
+  shader.activate();
+
   for (int i = 0; i < meshes.size(); ++i) {
     meshes[i].draw(shader);
   }