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

diff --git a/src/main.cpp b/src/main.cpp
index 8bdede6..564560d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -2,12 +2,18 @@
 
 #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>
@@ -17,7 +23,7 @@ const char *vertexShaderSource = R"(
 #version 330 core
 
 layout (location = 0) in vec3 pos;
-layout (location = 0) in vec3 normal;
+layout (location = 1) in vec3 normal;
 
 out vec3 FragPos;
 out vec3 Normal;
@@ -65,7 +71,7 @@ void main()
 std::vector<float> vertices;
 std::vector<GLuint> indices;
 
-glm::vec3 lightPos(1.2f, 0.5f, 2.0f);
+glm::vec3 lightPos(1.2f, 5.0f, 2.0f);
 
 void load(const std::string &filename, std::vector<float> &vertices,
           std::vector<GLuint> &indices) {
@@ -73,7 +79,7 @@ void load(const std::string &filename, std::vector<float> &vertices,
 
   const aiScene *scene = importer.ReadFile(
       filename, aiProcess_CalcTangentSpace | aiProcess_Triangulate |
-                    aiProcess_SortByPType | aiProcess_GenNormals);
+                    aiProcess_SortByPType | aiProcess_GenSmoothNormals);
 
   for (int i = 0; i < scene->mMeshes[0]->mNumVertices; i++) {
     aiVector3D v = scene->mMeshes[0]->mVertices[i];
@@ -103,11 +109,13 @@ int main() {
   settings.majorVersion = 4;
   settings.minorVersion = 6;
 
-  sf::Window window(sf::VideoMode(800, 600), "Subsurface Scattering",
+  sf::RenderWindow window(sf::VideoMode(1600, 900), "Subsurface Scattering",
                     sf::Style::Default, settings);
   window.setVerticalSyncEnabled(true);
+  window.setMouseCursorGrabbed(true);
+  window.setMouseCursorVisible(false);
 
-  window.setActive(true);
+  ImGui::SFML::Init(window);
 
   // Initialize GLEW
 
@@ -181,9 +189,10 @@ int main() {
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indices.size(),
                indices.data(), GL_STATIC_DRAW);
 
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)0);
-  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)3);
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)(0));
   glEnableVertexAttribArray(0);
+  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)(sizeof(float) * 3));
+  glEnableVertexAttribArray(1);
 
   glBindVertexArray(0);
 
@@ -191,47 +200,136 @@ int main() {
 
   glm::mat4 model = glm::scale(glm::mat4(1.0f), glm::vec3(0.01f, 0.01f, 0.01f));
 
+  struct {
+    float camX = 0;
+    float camZ = -5;
+    int mouseX = 0;
+    int mouseY = 0;
+  } arcball;
+
+  struct {
+    int mouseX = 0;
+    int mouseY = 0;
+  } freecam;
+
+  glm::vec3 camPos = glm::vec3(0, 0, -3);
+  glm::vec3 camForward = glm::vec3(0, 0, 1);
+  glm::vec3 camUp = glm::vec3(0, 1, 0);
+
   glm::mat4 view =
-      glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -3.0f));
+      glm::lookAt(glm::vec3(arcball.camX, 0.0, arcball.camZ), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
 
   glm::mat4 proj =
-      glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 1000.0f);
+      glm::perspective(glm::radians(45.0f), (float)window.getSize().x / window.getSize().y, 0.001f, 1000.0f);
+
+  struct {
+    bool catchMouse = false;
+    bool wireframe = false;
+    bool freecam = false;
+    float radius = 1.0f;
+  } options;
 
-  bool wireframe = false;
+  sf::Clock deltaClock;
 
   bool running = true;
   while (running) {
     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;
+        case keys::C:
+          options.catchMouse = !options.catchMouse;
+          break;
+        case keys::R:
+          freecam.mouseX = freecam.mouseY = 0;
+          break;
+        }
+      } else if (event.type == sf::Event::EventType::MouseWheelScrolled) {
+        options.radius -= event.mouseWheelScroll.delta / 5.0f;
+      }
+    }
+
+    int mouseDeltaX = sf::Mouse::getPosition(window).x - window.getSize().x / 2;
+    int mouseDeltaY = sf::Mouse::getPosition(window).y - window.getSize().y / 2;
+
+    if (options.catchMouse) {
+      sf::Mouse::setPosition(sf::Vector2i(
+        window.getSize().x / 2,
+        window.getSize().y / 2
+      ), window);
+
+      if (options.freecam) {
+        freecam.mouseX += mouseDeltaX;
+        freecam.mouseY += mouseDeltaY;
+
+        camForward = glm::rotate(glm::vec3(0, 0, 1), freecam.mouseY / 500.0f, glm::vec3(1, 0, 0));
+        camForward = glm::rotate(camForward, -freecam.mouseX / 500.0f, glm::vec3(0, 1, 0));
+
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) {
+          camPos += camForward / 20.0f;
+        }
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) {
+          camPos -= camForward / 20.0f;
+        }
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) {
+          glm::vec3 camLeft = glm::rotate(glm::vec3(0, 0, 1), -freecam.mouseX / 500.0f + glm::radians(90.0f), glm::vec3(0, 1, 0));
+          camPos += camLeft / 20.0f;
+        }
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) {
+          glm::vec3 camRight = glm::rotate(glm::vec3(0, 0, 1), -freecam.mouseX / 500.0f - glm::radians(90.0f), glm::vec3(0, 1, 0));
+          camPos += camRight / 20.0f;
+        }
+      } else {
+        if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
+          arcball.mouseX += mouseDeltaX;
+          arcball.mouseY += mouseDeltaY;
         }
       }
     }
 
+
+
     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);
 
-    model = glm::rotate(model, glm::radians(0.2f), glm::vec3(0.0f, 1.0f, 0.0f));
+    //rotate
+    //model = glm::rotate(model, glm::radians(0.2f), glm::vec3(0.0f, 1.0f, 0.0f));
+
+    if (options.freecam) {
+      view = glm::lookAt(camPos, camPos + camForward, camUp);
+    } else {
+      float angle = arcball.mouseY / 200.0f;
+      if (angle > glm::radians(89.0f)) {
+        angle = glm::radians(89.0f);
+        arcball.mouseY = angle * 200.0f;
+      }
+      if (angle < glm::radians(-89.0f)) {
+        angle = glm::radians(-89.0f);
+        arcball.mouseY = angle * 200.0f;
+      }
+      arcball.camX = sin(angle) * exp(options.radius);
+      arcball.camZ = cos(angle) * exp(options.radius);
+      view = glm::lookAt(glm::vec3(0.0, arcball.camX, arcball.camZ), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
+      view = glm::rotate(view, arcball.mouseX / 100.0f, glm::vec3(0, 1, 0));
+    }
 
     glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1,
                        GL_FALSE, glm::value_ptr(model));
@@ -249,6 +347,26 @@ int main() {
     glBindVertexArray(VAO);
     glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
     glBindVertexArray(0);
+    
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+    ImGui::SFML::Update(window, deltaClock.restart());
+
+    ImGui::Begin("Options");
+    ImGui::LabelText("Cursor Locked", "%d", options.catchMouse);
+    ImGui::Checkbox("Wireframe", &options.wireframe);
+    ImGui::Checkbox("Free Cam", &options.freecam);
+    if (options.freecam) {
+      ImGui::LabelText("Position", "%f %f %f", camPos.x, camPos.y, camPos.z);
+      ImGui::LabelText("Forward", "%f %f %f", camForward.x, camForward.y, camForward.z);
+      ImGui::LabelText("Mouse", "%d %d", freecam.mouseX, freecam.mouseY);
+    } else {
+      ImGui::LabelText("Rotation", "%f %f", arcball.camX, arcball.camZ);
+      ImGui::InputFloat("Radius", &options.radius);
+    }
+    ImGui::End();
+
+    ImGui::SFML::Render(window);
 
     window.display();
   }