fix lighting, add cam

1 files changed, 137 insertions, 19 deletions

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();

   }