Camera

ParticleEngine/InputManager.cpp

@@ -82,24 +82,28 @@ void InputManager::keyReleased(GLFWwindow *window, int key, ParticleEngineLaunch
 }
 
 void InputManager::keyRepeated(GLFWwindow *window, int key, ParticleEngineLauncher *engine) {
-    //switch (key) {
-    //    case GLFW_KEY_UP: {
-    //        engine->scene->translateCamera(Vector3d(0, 0, translationSpeed));
-    //        break;
-    //    }
-    //    case GLFW_KEY_DOWN: {
-    //        engine->scene->translateCamera(Vector3d(0, 0, -translationSpeed));
-    //        break;
-    //    }
-    //    case GLFW_KEY_LEFT: {
-    //        engine->scene->translateCamera(Vector3d(+translationSpeed, 0, 0));
-    //        break;
-    //    }
-    //    case GLFW_KEY_RIGHT: {
-    //        engine->scene->translateCamera(Vector3d(-translationSpeed, 0, 0));
-    //        break;
-    //    }
-    //}
+    Camera *camera = engine->scene->getCameraPtr();
+    switch (key) {
+        case GLFW_KEY_UP: {
+            camera->moveForward(movementSpeed);
+            break;
+        }
+        case GLFW_KEY_DOWN: {
+            camera->moveBackward(movementSpeed);
+            break;
+        }
+        case GLFW_KEY_LEFT: {
+            camera->moveLeft(movementSpeed);
+            break;
+        }
+        case GLFW_KEY_RIGHT : {
+            camera->moveRight(movementSpeed);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
 }
 
 void InputManager::scroll_callback(GLFWwindow *window, double xOffset, double yOffset) {
@@ -108,23 +112,15 @@ void InputManager::scroll_callback(GLFWwindow *window, double xOffset, double yO
 }
 
 void InputManager::cursor_position_callback(GLFWwindow *window, double xPos, double yPos) {
-    auto *engine = (ParticleEngineLauncher *) glfwGetWindowUserPointer(window);
     if (mouseRightButtonPressed) {
-        engine->scene->translateCamera(
-                {movementSpeed * (mouseLastPosX - (float) xPos), movementSpeed * ((float) yPos - mouseLastPosY), 0});
+        auto *engine = (ParticleEngineLauncher *) glfwGetWindowUserPointer(window);
+        Camera *camera = engine->scene->getCameraPtr();
+        float xOffset = static_cast<float>(xPos) - mouseLastPosX;
+        float yOffset = mouseLastPosY - static_cast<float>(yPos);
+        camera->processMouseMovement(xOffset, yOffset);
     }
-
     mouseLastPosX = static_cast<float>(xPos);
     mouseLastPosY = static_cast<float>(yPos);
-
-//    if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_MIDDLE) == GLFW_PRESS) {
-//        auto *engine = (ParticleEngineLauncher *) glfwGetWindowUserPointer(window);
-//        engine->scene->rotateCamera(Vector3d(0, 1, 0), rotationSpeed * (xPos - mouseLastPosX));
-//        engine->scene->rotateCamera(Vector3d(1, 0, 0), rotationSpeed * (yPos - mouseLastPosY));
-//    } else {
-//        mouseLastPosX = xPos;
-//        mouseLastPosY = yPos;
-//    }
 }
 
 void InputManager::mouse_button_callback(GLFWwindow *window, int button, int action, int mods) {

ParticleEngine/Scene/Camera.cpp

@@ -1,34 +1,54 @@
 #include "Camera.h"
 
 Camera::Camera() {
-    viewMatrix = glm::lookAt(glm::vec3(0.0f, 0.0f, 30.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, -1.0f, 0.0f));
 }
 
 Camera::~Camera() = default;
 
-void Camera::update() {
-
+void Camera::moveForward(float speed) {
+    cameraPos += cameraMoveSpeed * cameraFront;
 }
 
-void Camera::setPosition(const Vector3d &vector3D) {
-    viewMatrix = glm::lookAt(glm::vec3(vector3D.getx(), vector3D.gety(), vector3D.getz()),
-                             glm::vec3(0.0f, 0.0f, 0.0f),
-                             glm::vec3(0.0f, 1.0f, 0.0f));
+void Camera::moveBackward(float speed) {
+
+    cameraPos -= cameraMoveSpeed * cameraFront;
 }
 
-void Camera::translate(const Vector3d &vector3D) {
-    viewMatrix = glm::translate(viewMatrix, glm::vec3(vector3D.getx(), vector3D.gety(), vector3D.getz()));
+void Camera::moveLeft(float speed) {
+
+    cameraPos -= glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraMoveSpeed;
 }
 
-void Camera::rotate(const Vector3d &vector3D, float angle) {
-    viewMatrix = glm::rotate(viewMatrix, angle, glm::vec3(vector3D.getx(), vector3D.gety(), vector3D.getz()));
+void Camera::moveRight(float speed) {
+
+    cameraPos += glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraMoveSpeed;
 }
 
-glm::mat4 Camera::getViewMatrix() const {
-    return viewMatrix;
+void Camera::processMouseMovement(float xOffset, float yOffset) {
+    xOffset *= cameraSensitivity;
+    yOffset *= cameraSensitivity;
+
+    yaw += xOffset;
+    pitch += yOffset;
+
+    if (constrainPitch) {
+        if (pitch > 89.0f)
+            pitch = 89.0f;
+        if (pitch < -89.0f)
+            pitch = -89.0f;
+    }
+
+    glm::vec3 front;
+    front.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
+    front.y = sin(glm::radians(pitch));
+    front.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
+    cameraFront = glm::normalize(front);
 }
 
 float Camera::getFov() const {
     return fov;
 }
 
+glm::mat4 Camera::getViewMatrix() const {
+    return glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
+}

ParticleEngine/Scene/Camera.h

@@ -8,22 +8,35 @@
 #include "../Utility/Vector3d.h"
 
 class Camera {
-private:
-    glm::mat4 viewMatrix;
+public:
     const float fov = 90.0f;// In degrees
 
+    glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 30.0f);
+    glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
+    glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
+
+    float cameraMoveSpeed = 0.4f;
+    float cameraSensitivity = 0.1f;
+
+    float yaw = -90.0f;
+    float pitch = 0.0f;
+
+    bool constrainPitch = true;
+
 public:
     Camera();
 
     ~Camera();
 
-    void update();
+    void moveForward(float speed);
+
+    void moveBackward(float speed);
 
-    void setPosition(const Vector3d &vector3D);
+    void moveLeft(float speed);
 
-    void translate(const Vector3d &vector3D);
+    void moveRight(float speed);
 
-    void rotate(const Vector3d &vector3D, float angle);
+    void processMouseMovement(float xOffset, float yOffset);
 
     glm::mat4 getViewMatrix() const;
 

ParticleEngine/Scene/GameObject.cpp

@@ -90,7 +90,7 @@ void GameObject::draw(int display_w, int display_h, glm::mat4 view, float fov) {
     //Shader use
     shader.use();
     shader.setMat4("model",
-                   glm::translate(model, glm::vec3(-transform.positionX, -transform.positionY, -transform.positionZ)));
+                   glm::translate(model, glm::vec3(transform.positionX, transform.positionY, transform.positionZ)));
     shader.setMat4("view", view);
     shader.setMat4("projection", projection);
 

ParticleEngine/Scene/Scene.cpp

@@ -10,13 +10,13 @@
 #include "Components/PhysicalComponent/Particle/Particle.h"
 #include "Components/Collider/Collider.h"
 
-Scene::Scene(int windowWidth, int windowHeight):  particleCollide(1) {
+Scene::Scene(int windowWidth, int windowHeight) : particleCollide(1) {
     this->windowWidth = windowWidth;
     this->windowHeight = windowHeight;
 //    gameObjects.push_back(new GameObject(Cube(1)));
 //    gameObjects.push_back(new GameObject(Sphere(1, 20, 20)));
 //    gameObjects.push_back(new GameObject(MyCube(1)));
-	particleContactGeneratorRegistry.addParticleGenerator(&particleCollide);
+    particleContactGeneratorRegistry.addParticleGenerator(&particleCollide);
     create();
 }
 
@@ -70,10 +70,10 @@ void Scene::update(float deltaTime) {
 
 
     // Detect collision
-	ParticleContact* particleContacts = particleContactGeneratorRegistry.generateAllContacts();
+    ParticleContact *particleContacts = particleContactGeneratorRegistry.generateAllContacts();
 
     // Resolve collisions
-	ParticleContact test = particleContacts[0];
+    ParticleContact test = particleContacts[0];
     particleContactResolver.resolveContact(particleContacts, particleContactGeneratorRegistry.getSize(), deltaTime);
 }
 
@@ -97,27 +97,27 @@ void Scene::addGameObject(GameObject *gameObject) {
 }
 
 void Scene::translateCamera(const Vector3d &vector3D) {
-    camera.translate(vector3D);
+//    camera.translate(vector3D);
 }
 
 //void Scene::rotateCamera(Vector3d vector3D, float angle) {
 //    camera.rotate(vector3D, angle);
 //}
 
 void Scene::setCameraPosition(const Vector3d &position) {
-    camera.setPosition(position);
+//    camera.setPosition(position);
 }
 
 ParticleContactGeneratorRegistry Scene::getParticleContactGeneratorRegistry() {
-	return particleContactGeneratorRegistry;
+    return particleContactGeneratorRegistry;
 }
 
 unsigned int Scene::getFrameBufferId() const {
     return fbo;
 }
 
 void Scene::addParticleCollider(ParticleCollider particleCollider) {
-	particleCollide.addCollider(particleCollider);
+    particleCollide.addCollider(particleCollider);
 }
 
 
@@ -142,6 +142,10 @@ GameObject *Scene::getPtrGameObjectByIndex(int index) const {
     return gameObjects[index];
 }
 
+Camera *Scene::getCameraPtr() {
+    return &camera;
+}
+
 
 
 

ParticleEngine/Scene/Scene.h

@@ -9,7 +9,7 @@
 #include "Axis.h"
 #include "../Contact/ParticlesContactGeneratorRegistry.h"
 #include "../Contact/ParticleContactResolver.h"
-#include "../Contact/ContactGenerator/ParticleCollide.h"   
+#include "../Contact/ContactGenerator/ParticleCollide.h"
 
 class GameObject;
 
@@ -23,9 +23,9 @@ class Scene {
     Camera camera;
     PhysicHandler physicHandler;
     std::vector<GameObject *> gameObjects;
-	ParticleContactGeneratorRegistry particleContactGeneratorRegistry= ParticleContactGeneratorRegistry(1000000);
-	ParticleContactResolver particleContactResolver=ParticleContactResolver(2000000);
-	ParticleCollide particleCollide;
+    ParticleContactGeneratorRegistry particleContactGeneratorRegistry = ParticleContactGeneratorRegistry(1000000);
+    ParticleContactResolver particleContactResolver = ParticleContactResolver(2000000);
+    ParticleCollide particleCollide;
 
     // View settings
     bool wireFrame = false;
@@ -35,7 +35,6 @@ class Scene {
     unsigned int fbo;
 
 
-
 public:
     Scene(int windowWidth, int windowHeight);
 
@@ -62,7 +61,7 @@ class Scene {
     void setCameraPosition(const Vector3d &position);
 
 public:
-	ParticleContactGeneratorRegistry getParticleContactGeneratorRegistry();
+    ParticleContactGeneratorRegistry getParticleContactGeneratorRegistry();
 
     void addParticleCollider(ParticleCollider particleCollider);
 
@@ -75,6 +74,8 @@ class Scene {
     bool *getPtrShowAxis();
 
     GameObject *getPtrGameObjectByIndex(int index) const;
+
+    Camera *getCameraPtr();
 };
 
 #endif //SCENE_H

ParticleEngine/Utility/Vector3d.cpp

@@ -111,8 +111,9 @@ Vector3d Vector3d::normalize() const {
     if (n != 0) {
         return {m_x / n, m_y / n, m_z / n};
     } else {
-        std::cerr << "Error: cannot normalize null vector" << std::endl;
-        exit(1);
+//        std::cerr << "Error: cannot normalize null vector" << std::endl;
+//        exit(1);
+        return {0, 0, 0};
     }
 }
 

imgui.ini

@@ -49,7 +49,7 @@ Size=872,706
 Collapsed=0
 
 [Window][Scene View]
-Pos=397,24
+Pos=396,25
 Size=869,477
 Collapsed=0