X-Git-Url: https://gitweb.ps.run/subsurface_scattering/blobdiff_plain/eb13742f576ca34a165a5743d26c43fb0706a70e..e03792c2d5620ca07ac50717062df846927027c0:/src/main.cpp

diff --git a/src/main.cpp b/src/main.cpp
index 8bdede6..ddba48c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,150 +1,284 @@
 #include <stdio.h>
+#include <fstream>
 
 #include <GL/glew.h>
 
+#define GLM_ENABLE_EXPERIMENTAL
+
 #include <glm/glm.hpp>
+#include <glm/gtx/rotate_vector.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
 #include <SFML/OpenGL.hpp>
-#include <SFML/Window.hpp>
+#include <SFML/Graphics.hpp>
+
+#include <imgui.h>
+#include <imgui-SFML.h>
 
 #include <assimp/Importer.hpp>
 #include <assimp/postprocess.h>
 #include <assimp/scene.h>
 
-const char *vertexShaderSource = R"(
-#version 330 core
+/*
+
+TODO:
+- ShadowMap to fbo
+- Save Depth to fbo
+
+*/
+
+float samplePositions[] = {
+  0.000000f,  0.000000f,
+  1.633992f,  0.036795f,
+  0.177801f,  1.717593f,
+  -0.194906f,  0.091094f,
+  -0.239737f, -0.220217f,
+  -0.003530f, -0.118219f,
+  1.320107f, -0.181542f,
+  5.970690f,  0.253378f,
+  -1.089250f,  4.958349f,
+  -4.015465f,  4.156699f,
+  -4.063099f, -4.110150f,
+  -0.638605f, -6.297663f,
+  2.542348f, -3.245901f
+};
+
+float sampleWeights[] = {
+  0.220441f,  0.487000f, 0.635000f,
+  0.076356f,  0.064487f, 0.039097f,
+  0.116515f,  0.103222f, 0.064912f,
+  0.064844f,  0.086388f, 0.062272f,
+  0.131798f,  0.151695f, 0.103676f,
+  0.025690f,  0.042728f, 0.033003f,
+  0.048593f,  0.064740f, 0.046131f,
+  0.048092f,  0.003042f, 0.000400f,
+  0.048845f,  0.005406f, 0.001222f,
+  0.051322f,  0.006034f, 0.001420f,
+  0.061428f,  0.009152f, 0.002511f,
+  0.030936f,  0.002868f, 0.000652f,
+  0.073580f,  0.023239f, 0.009703f
+};
+
+struct model {
+  std::vector<float> vertices;
+  std::vector<GLuint> indices;
+
+  void draw() {
+    if (VAO == 0) initVAO();
+    glBindVertexArray(VAO);
+    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
+    glBindVertexArray(0);
+  }
 
-layout (location = 0) in vec3 pos;
-layout (location = 0) in vec3 normal;
+private:
+  void initVAO() {
+    GLuint VBO;
+    glGenBuffers(1, &VBO);
 
-out vec3 FragPos;
-out vec3 Normal;
+    GLuint EBO;
+    glGenBuffers(1, &EBO);
 
-uniform mat4 model;
-uniform mat4 view;
-uniform mat4 projection;
+    glGenVertexArrays(1, &VAO);
 
-void main()
-{
-  gl_Position = projection * view * model * vec4(pos, 1.0);
-  FragPos = vec3(model * vec4(pos, 1));
-  Normal = normal;
-}
-)";
+    glBindVertexArray(VAO);
 
-const char *fragmentShaderSource = R"(
-#version 330 core
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vertices.size(),
+                vertices.data(), GL_STATIC_DRAW);
 
-in vec3 FragPos;
-in vec3 Normal;
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indices.size(),
+                indices.data(), GL_STATIC_DRAW);
 
-out vec4 FragColor;
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)(0));
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)(sizeof(float) * 3));
 
-uniform vec3 objectColor;
-uniform vec3 lightColor;
-uniform vec3 lightPos;
+    glBindVertexArray(0);
+  }
+  GLuint VAO = 0;
+};
 
-void main()
-{
-  vec3 norm = normalize(Normal);
-  vec3 lightDir = normalize(lightPos - FragPos);
 
-  float diff = max(dot(norm, lightDir), 0.0);
-  vec3 diffuse = diff * lightColor;
+struct freecam {
+  glm::vec3 pos = glm::vec3(0, 0, -1);
+  glm::vec2 rot = glm::vec2(0, 0);
 
-  float ambientStrength = 0.1;
-  vec3 ambient = ambientStrength * lightColor;
+  void update(sf::Window &window) {
+    int mouseDeltaX = sf::Mouse::getPosition(window).x - window.getSize().x / 2;
+    int mouseDeltaY = sf::Mouse::getPosition(window).y - window.getSize().y / 2;
 
-  vec3 result = (ambient + diffuse) * objectColor;
-  FragColor = vec4(result, 1.0f);
-}
-)";
+    rot.x += mouseDeltaX;
+    rot.y += mouseDeltaY;
+
+    forward = glm::rotate(glm::vec3(0, 0, 1), rot.y / angleFactor, glm::vec3(1, 0, 0));
+    forward = glm::rotate(forward, -rot.x / angleFactor, glm::vec3(0, 1, 0));
+
+    glm::vec3 left = glm::rotate(glm::vec3(0, 0, 1), -rot.x / angleFactor + glm::radians(90.0f), glm::vec3(0, 1, 0));
+
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::LShift))
+      moveFactor = 200;
+    else
+      moveFactor = 20;
+
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::W))
+      pos += forward / moveFactor;
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
+      pos -= forward / moveFactor;
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
+      pos += left / moveFactor;
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
+      pos -= left / moveFactor;
+
+    limit();
+  }
+
+  void limit() {
+    rot.x = fmod(rot.x, glm::radians(360.0f) * angleFactor);
+    rot.y = fmod(rot.y, glm::radians(360.0f) * angleFactor);
+  }
+
+  glm::mat4 getViewMatrix() {
+    forward = glm::rotate(glm::vec3(0, 0, 1), rot.y / angleFactor, glm::vec3(1, 0, 0));
+    forward = glm::rotate(forward, -rot.x / angleFactor, glm::vec3(0, 1, 0));
+    glm::mat4 result = glm::lookAt(pos, pos + forward, up);
+    return result;
+  }
+
+private:
+  glm::vec3 forward = glm::vec3(0, 0, 1);
+  glm::vec3 up = glm::vec3(0, 1, 0);
+
+  const float angleFactor = 200;
+  float moveFactor = 20;
+};
+
+
+struct arccam {
+  glm::vec2 rot = glm::vec2(0, 0);
+  float radius = 1;
+
+  void update(sf::Window &window) {
+    int mouseDeltaX = sf::Mouse::getPosition(window).x - window.getSize().x / 2;
+    int mouseDeltaY = sf::Mouse::getPosition(window).y - window.getSize().y / 2;
+
+    rot.x += mouseDeltaX;
+    rot.y += mouseDeltaY;
+
+    limit(-89, 89);
+  }
+
+  void limit(float minY, float maxY) {
+    float angleX = rot.x / angleFactor;
+    float angleY = rot.y / angleFactor;
 
-std::vector<float> vertices;
-std::vector<GLuint> indices;
+    rot.x = fmod(rot.x, glm::radians(360.0f) * angleFactor);
 
-glm::vec3 lightPos(1.2f, 0.5f, 2.0f);
+    if (angleY > glm::radians(maxY))
+      rot.y = glm::radians(maxY) * angleFactor;
+    if (angleY < glm::radians(minY))
+      rot.y = glm::radians(minY) * angleFactor;
+  }
+
+  glm::vec3 getPos() {
+    float angle = rot.y / angleFactor;
+  
+    float camY = sin(angle) * exp(radius);
+    float camZ = cos(angle) * exp(radius);
+
+    glm::vec3 result(0.0, camY, camZ);
+    return glm::rotate(result, -rot.x / angleFactor, glm::vec3(0, 1, 0));
+  }
+
+  glm::mat4 getViewMatrix() {
+    float angle = rot.y / angleFactor;
+  
+    float camY = sin(angle) * exp(radius);
+    float camZ = cos(angle) * exp(radius);
+    glm::mat4 result = glm::lookAt(glm::vec3(0.0, camY, camZ), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
+    result = glm::rotate(result, rot.x / angleFactor, glm::vec3(0, 1, 0));
+
+    return result;
+  }
+
+private:
+  const float angleFactor = 200;
+};
 
-void load(const std::string &filename, std::vector<float> &vertices,
-          std::vector<GLuint> &indices) {
+
+std::string readFile(std::string filename) {
+  std::ifstream ifs(filename, std::ios::binary);
+  std::string result, line;
+  while (std::getline(ifs, line))
+    result += line + "\n";
+
+  return result;
+}
+
+model loadModel(const std::string &filename) {
   Assimp::Importer importer;
 
   const aiScene *scene = importer.ReadFile(
       filename, aiProcess_CalcTangentSpace | aiProcess_Triangulate |
-                    aiProcess_SortByPType | aiProcess_GenNormals);
+                    aiProcess_SortByPType | aiProcess_GenSmoothNormals);
+
+  model result;
 
   for (int i = 0; i < scene->mMeshes[0]->mNumVertices; i++) {
     aiVector3D v = scene->mMeshes[0]->mVertices[i];
     aiVector3D n = scene->mMeshes[0]->mNormals[i];
-    vertices.push_back(v.x);
-    vertices.push_back(v.y);
-    vertices.push_back(v.z);
-    vertices.push_back(n.x);
-    vertices.push_back(n.y);
-    vertices.push_back(n.z);
+    result.vertices.push_back(v.x);
+    result.vertices.push_back(v.y);
+    result.vertices.push_back(v.z);
+    result.vertices.push_back(n.x);
+    result.vertices.push_back(n.y);
+    result.vertices.push_back(n.z);
   }
 
   for (int i = 0; i < scene->mMeshes[0]->mNumFaces; i++) {
     aiFace f = scene->mMeshes[0]->mFaces[i];
     for (int j = 0; j < f.mNumIndices; j++) {
-      indices.push_back(f.mIndices[j]);
+      result.indices.push_back(f.mIndices[j]);
     }
   }
-}
-
-int main() {
-  // Window Setup
-
-  sf::ContextSettings settings;
-  settings.depthBits = 24;
-  settings.antialiasingLevel = 0;
-  settings.majorVersion = 4;
-  settings.minorVersion = 6;
-
-  sf::Window window(sf::VideoMode(800, 600), "Subsurface Scattering",
-                    sf::Style::Default, settings);
-  window.setVerticalSyncEnabled(true);
-
-  window.setActive(true);
-
-  // Initialize GLEW
 
-  if (glewInit() != GLEW_OK) {
-  }
-
-  load("models/Isotrop-upperjaw.ply", vertices, indices);
-
-  // Compile Shaders
+  return result;
+}
 
-  GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
-  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
-  glCompileShader(vertexShader);
+GLuint compileShaders(const char *vertFilename, const char *fragFilename) {
+  GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
+  std::string vertSource = readFile(vertFilename);
+  const char *vertAddr = vertSource.c_str();
+  glShaderSource(vertShader, 1, &vertAddr, NULL);
+  glCompileShader(vertShader);
 
   int success;
   char infoLog[512];
-  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
+  glGetShaderiv(vertShader, GL_COMPILE_STATUS, &success);
   if (!success) {
-    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
-    printf("Error compiling vertex shader: %s\n", infoLog);
+    glGetShaderInfoLog(vertShader, 512, NULL, infoLog);
+    printf("Error compiling vertex shader(%s): %s\n", vertFilename, infoLog);
   }
 
-  GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
-  glCompileShader(fragmentShader);
+  GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);
+  std::string fragSource = readFile(fragFilename);
+  const char *fragAddr = fragSource.c_str();
+  glShaderSource(fragShader, 1, &fragAddr, NULL);
+  glCompileShader(fragShader);
 
-  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
+  glGetShaderiv(fragShader, GL_COMPILE_STATUS, &success);
   if (!success) {
-    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
-    printf("Error compiling fragment shader: %s\n", infoLog);
+    glGetShaderInfoLog(fragShader, 512, NULL, infoLog);
+    printf("Error compiling fragment shader(%s): %s\n", fragFilename, infoLog);
   }
 
   // Link Shader Program
 
   GLuint shaderProgram = glCreateProgram();
-  glAttachShader(shaderProgram, vertexShader);
-  glAttachShader(shaderProgram, fragmentShader);
+  glAttachShader(shaderProgram, vertShader);
+  glAttachShader(shaderProgram, fragShader);
   glLinkProgram(shaderProgram);
 
   glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
@@ -153,102 +287,324 @@ int main() {
     printf("Error linking shader program: %s\n", infoLog);
   }
 
-  glDeleteShader(vertexShader);
-  glDeleteShader(fragmentShader);
+  glDeleteShader(vertShader);
+  glDeleteShader(fragShader);
 
-  // Create VBO
+  return shaderProgram;
+}
 
-  GLuint VBO;
-  glGenBuffers(1, &VBO);
 
-  // Create EBO
+struct framebuffer {
+  framebuffer(const char *vertFilename, const char *fragFilename, int width, int height) {
+    glGenFramebuffers(1, &fbo);
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    
+    glGenTextures(1, &renderTexture);
+    glBindTexture(GL_TEXTURE_2D, renderTexture);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    //glBindTexture(GL_TEXTURE_2D, 0);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTexture, 0);
+
+    glGenRenderbuffers(1, &rbo);
+    glBindRenderbuffer(GL_RENDERBUFFER, rbo);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
+    //glBindRenderbuffer(GL_RENDERBUFFER, 0);
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo);
+
+    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) {
+      printf("Successfully created framebuffer\n");
+    }
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    
+    screenShaderProgram = compileShaders(vertFilename, fragFilename);
+    glUseProgram(screenShaderProgram);
+    glUniform1i(glGetUniformLocation(screenShaderProgram, "screenTexture"), 0);
+
+    // Screen VAO
+    
+    glGenBuffers(1, &screenVBO);
+
+    glGenVertexArrays(1, &screenVAO);
+
+    glBindVertexArray(screenVAO);
+
+    float screenVerts[] = {
+      -1.0f, +1.0f, +0.0f, +1.0f,
+      -1.0f, -1.0f, +0.0f, +0.0f,
+      +1.0f, -1.0f, +1.0f, +0.0f,
+  
+      -1.0f, +1.0f, +0.0f, +1.0f,
+      +1.0f, -1.0f, +1.0f, +0.0f,
+      +1.0f, +1.0f, +1.0f, +1.0f,
+    };
+
+    glBindBuffer(GL_ARRAY_BUFFER, screenVBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6 * 4,
+                screenVerts, GL_STATIC_DRAW);
+
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*)(0));
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*)(sizeof(float) * 2));
 
-  GLuint EBO;
-  glGenBuffers(1, &EBO);
+    glBindVertexArray(0);
+  }
+  ~framebuffer() {
+    glDeleteFramebuffers(1, &fbo);
+  }
+  
+  GLuint fbo;
+  GLuint renderTexture;
+  GLuint rbo;
+  GLuint screenShaderProgram;
+  GLuint screenVBO;
+  GLuint screenVAO;
+};
 
-  // Create VAO
+int main() {
+  // Window Setup
 
-  GLuint VAO;
-  glGenVertexArrays(1, &VAO);
+  const int width = 1600, height = 900;
 
-  glBindVertexArray(VAO);
+  sf::ContextSettings settings;
+  settings.depthBits = 24;
+  settings.antialiasingLevel = 0;
+  settings.majorVersion = 4;
+  settings.minorVersion = 6;
+
+  sf::RenderWindow window(sf::VideoMode(1600, 900), "Subsurface Scattering",
+                    sf::Style::Default, settings);
+  window.setVerticalSyncEnabled(true);
+
+  ImGui::SFML::Init(window);
+
+  // Initialize GLEW
 
-  glBindBuffer(GL_ARRAY_BUFFER, VBO);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vertices.size(),
-               vertices.data(), GL_STATIC_DRAW);
+  if (glewInit() != GLEW_OK) {
+  }
 
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
-  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indices.size(),
-               indices.data(), GL_STATIC_DRAW);
+  GLuint shaderProgramShadowmap = compileShaders("shaders/vert.glsl", "shaders/frag_shadowmap.glsl");
+  GLuint shaderProgramIrradiance = compileShaders("shaders/vert.glsl", "shaders/frag_irradiance.glsl");
 
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)0);
-  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)3);
-  glEnableVertexAttribArray(0);
+  model m = loadModel("models/Isotrop-upperjaw.ply");
 
-  glBindVertexArray(0);
+  arccam arcCam;
+  freecam freeCam;
+      
+  glm::vec3 lightPos(1.2f, 5.0f, 2.0f);
 
-  // Perspective
+  // MVP
 
   glm::mat4 model = glm::scale(glm::mat4(1.0f), glm::vec3(0.01f, 0.01f, 0.01f));
 
-  glm::mat4 view =
-      glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -3.0f));
+  glm::mat4 view;
+
+  glm::mat4 proj = glm::perspective(glm::radians(45.0f), (float)window.getSize().x / window.getSize().y, 0.001f, 1000.0f);
+
+  // Framebuffer
+  framebuffer fb_shadowmap("shaders/fbo_vert.glsl", "shaders/fbo_frag.glsl", width, height);
+  framebuffer fb_irradiance("shaders/fbo_vert.glsl", "shaders/fbo_frag.glsl", width, height);
+
+  // Config
+
+  struct {
+    bool wireframe = false;
+    bool freecam = false;
+    int renderState = 0;
+    float color[3] = { 0.7f, 0.4f, 0.4f };
+  } options;
 
-  glm::mat4 proj =
-      glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 1000.0f);
+  sf::Clock deltaClock;
 
-  bool wireframe = false;
+  bool prevMouse = false;
 
   bool running = true;
   while (running) {
+    // Events
+
     sf::Event event;
     while (window.pollEvent(event)) {
-      if (event.type == sf::Event::Closed) {
+      ImGui::SFML::ProcessEvent(event);
+
+      if (event.type == sf::Event::EventType::Closed) {
         running = false;
-      } else if (event.type == sf::Event::Resized) {
+      } else if (event.type == sf::Event::EventType::Resized) {
         glViewport(0, 0, event.size.width, event.size.height);
-      } else if (event.type == sf::Event::KeyReleased) {
+      } else if (event.type == sf::Event::EventType::KeyReleased) {
         using keys = sf::Keyboard;
         switch (event.key.code) {
-        case keys::W:
-          wireframe = !wireframe;
-          break;
         case keys::Escape:
           running = false;
           break;
         }
+      } else if (event.type == sf::Event::EventType::MouseWheelScrolled) {
+        if (! options.freecam) {
+          arcCam.radius -= event.mouseWheelScroll.delta / 5.0f;
+        }
       }
     }
 
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    // Update
+
+    if (sf::Mouse::isButtonPressed(sf::Mouse::Right)) {
+      window.setMouseCursorVisible(false);
+
+      if (prevMouse) {
+        if (options.freecam)
+          freeCam.update(window);
+        else
+          arcCam.update(window);
+      }
+
+
+      sf::Mouse::setPosition(sf::Vector2i(
+          window.getSize().x / 2,
+          window.getSize().y / 2
+        ), window);  
+    } else {
+      window.setMouseCursorVisible(true);
+    }
 
+    prevMouse = sf::Mouse::isButtonPressed(sf::Mouse::Right);
+
+    // Render Shadowmap
+
+    glBindFramebuffer(GL_FRAMEBUFFER, fb_shadowmap.fbo);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glEnable(GL_DEPTH_TEST);
 
-    if (wireframe)
+    if (options.wireframe)
       glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
     else
       glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
-    glUseProgram(shaderProgram);
+    glUseProgram(shaderProgramShadowmap);
+    
+    if (options.freecam)
+      view = freeCam.getViewMatrix();
+    else
+      view = arcCam.getViewMatrix();
+    
+    glUniformMatrix4fv(
+      glGetUniformLocation(shaderProgramShadowmap, "model"),
+      1, GL_FALSE, glm::value_ptr(model));
+    glUniformMatrix4fv(
+      glGetUniformLocation(shaderProgramShadowmap, "view"),
+      1, GL_FALSE, glm::value_ptr(view));
+    glUniformMatrix4fv(
+      glGetUniformLocation(shaderProgramShadowmap, "projection"),
+      1, GL_FALSE, glm::value_ptr(proj));
+
+    glUniform3fv(
+      glGetUniformLocation(shaderProgramShadowmap, "lightPos"),
+      1, glm::value_ptr(lightPos));
+
+    m.draw();
+
+    // Render irradiance
+
+    glBindFramebuffer(GL_FRAMEBUFFER, fb_irradiance.fbo);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glEnable(GL_DEPTH_TEST);
 
-    model = glm::rotate(model, glm::radians(0.2f), glm::vec3(0.0f, 1.0f, 0.0f));
+    if (options.wireframe)
+      glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    else
+      glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
-    glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1,
-                       GL_FALSE, glm::value_ptr(model));
-    glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "view"), 1, GL_FALSE,
-                       glm::value_ptr(view));
-    glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "projection"), 1,
-                       GL_FALSE, glm::value_ptr(proj));
+    glUseProgram(shaderProgramIrradiance);
+    
+    if (options.freecam)
+      view = freeCam.getViewMatrix();
+    else
+      view = arcCam.getViewMatrix();
+    
+    glUniformMatrix4fv(
+      glGetUniformLocation(shaderProgramIrradiance, "model"),
+      1, GL_FALSE, glm::value_ptr(model));
+    glUniformMatrix4fv(
+      glGetUniformLocation(shaderProgramIrradiance, "view"),
+      1, GL_FALSE, glm::value_ptr(view));
+    glUniformMatrix4fv(
+      glGetUniformLocation(shaderProgramIrradiance, "projection"),
+      1, GL_FALSE, glm::value_ptr(proj));
+
+    glUniform3fv(
+      glGetUniformLocation(shaderProgramIrradiance, "objectColor"),
+      1, options.color);
+    glUniform3f(
+      glGetUniformLocation(shaderProgramIrradiance, "lightColor"),
+      1.0f, 1.0f, 1.0f);
+    glUniform3fv(
+      glGetUniformLocation(shaderProgramIrradiance, "lightPos"),
+      1, glm::value_ptr(lightPos));
+    glUniform3fv(
+      glGetUniformLocation(shaderProgramIrradiance, "viewPos"),
+      1, glm::value_ptr(options.freecam ? freeCam.pos : arcCam.getPos()));
+      
+    glUniform1i(glGetUniformLocation(shaderProgramIrradiance, "shadowmapTexture"), 0);
+    glActiveTexture(GL_TEXTURE0 + 0);
+    glBindTexture(GL_TEXTURE_2D, fb_shadowmap.renderTexture);
+
+    m.draw();
+
+    // Render fbo to screen
+    
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    glDisable(GL_DEPTH_TEST);
+    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glUseProgram(fb_irradiance.screenShaderProgram);
+
+    glUniform1i(glGetUniformLocation(fb_irradiance.screenShaderProgram, "screenWidth"), window.getSize().x);
+    glUniform1i(glGetUniformLocation(fb_irradiance.screenShaderProgram, "screenHeight"), window.getSize().y);
+    glUniform1i(glGetUniformLocation(fb_irradiance.screenShaderProgram, "renderState"), options.renderState);
+    glUniform2fv(glGetUniformLocation(fb_irradiance.screenShaderProgram, "samplePositions"), 13, samplePositions);
+    glUniform3fv(glGetUniformLocation(fb_irradiance.screenShaderProgram, "sampleWeights"), 13, sampleWeights);
+
+    glBindVertexArray(fb_irradiance.screenVAO);
+    glUniform1i(glGetUniformLocation(fb_irradiance.screenShaderProgram, "shadowmapTexture"), 0);
+    glUniform1i(glGetUniformLocation(fb_irradiance.screenShaderProgram, "irradianceTexture"), 1);
+    glActiveTexture(GL_TEXTURE0 + 0);
+    glBindTexture(GL_TEXTURE_2D, fb_shadowmap.renderTexture);
+    glActiveTexture(GL_TEXTURE0 + 1);
+    glBindTexture(GL_TEXTURE_2D, fb_irradiance.renderTexture);
+    glDrawArrays(GL_TRIANGLES, 0, 6);
+    glBindVertexArray(0);
 
-    glUniform3f(glGetUniformLocation(shaderProgram, "objectColor"), 1.0f, 0.5f,
-                0.31f);
-    glUniform3f(glGetUniformLocation(shaderProgram, "lightColor"), 1.0f, 1.0f,
-                1.0f);
-    glUniform3fv(glGetUniformLocation(shaderProgram, "lightPos"), 1, glm::value_ptr(lightPos));
+    ImGui::SFML::Update(window, deltaClock.restart());
+
+    ImGui::Begin("Options");
+    ImGui::Checkbox("Wireframe", &options.wireframe);
+    ImGui::Checkbox("Free Cam", &options.freecam);
+    ImGui::InputInt("Render State", &options.renderState);
+    ImGui::InputFloat3("Color", options.color, 2);
+    if (options.freecam) {
+      ImGui::LabelText("Position", "%f %f %f", freeCam.pos.x, freeCam.pos.y, freeCam.pos.z);
+      ImGui::LabelText("Rotation", "%f %f", freeCam.rot.x, freeCam.rot.y);
+      if (ImGui::Button("Reset")) {
+        freeCam.pos = glm::vec3(0, 0, -1);
+        freeCam.rot = glm::vec2(0);
+      }
+    } else {
+      ImGui::LabelText("Rotation", "%f %f", arcCam.rot.x, arcCam.rot.y);
+      ImGui::DragFloat("Radius", &arcCam.radius, 0.01f, -1.0f, 1.0f);
+      if (ImGui::Button("Reset")) {
+        arcCam.rot = glm::vec2(0);
+        arcCam.radius = 1;
+      }
+    }
+    ImGui::End();
 
-    glBindVertexArray(VAO);
-    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
-    glBindVertexArray(0);
+    ImGui::SFML::Render(window);
 
     window.display();
   }