orbital mode

engine/include/Camera.hpp

@@ -33,6 +33,20 @@ class Camera {
   void forwardMovement();
   void backwardMovement();
 
+  private:
+    void backwardMovementFPS();
+    void backwardMovementOrbital();
+    void forwardMovementFPS();
+    void forwardMovementOrbital();
+    void leftMovementFPS();
+    void leftMovementOrbital();
+    void rightMovementFPS();
+    void rightMovementOrbital();
+    void upMovementFPS();
+    void upMovementOrbital();
+    void downMovementFPS();
+    void downMovementOrbital();
+
   //   std::string toString();
 };
 

engine/src/Camera.cpp

@@ -10,6 +10,7 @@ Camera::Camera() {
   this->fov = 0;
   this->near = 0;
   this->far = 0;
+  this->type = FPS;
 }
 
 Camera::Camera(glm::vec3 position, glm::vec3 lookAt, glm::vec3 up, int fov, float near,
@@ -25,6 +26,8 @@ Camera::Camera(glm::vec3 position, glm::vec3 lookAt, glm::vec3 up, int fov, floa
   this->fov = fov;
   this->near = near;
   this->far = far;
+
+  this->type = FPS;
 }
 
 
@@ -38,46 +41,131 @@ Camera::Camera(const Camera& other) {
   this->far = other.far;
 }
 
-void Camera::backwardMovement() {
+void Camera::backwardMovementFPS() {
   glm::vec3 direction = glm::normalize(lookAt - position);
   position += direction;
   lookAt += direction;
 }
 
-void Camera::forwardMovement() {
+void Camera::backwardMovementOrbital() {
+  glm::vec3 direction = glm::normalize(lookAt - position);
+  position += direction;
+}
+
+void Camera::backwardMovement() {
+  if(type == FPS) {
+    backwardMovementFPS();
+  } else {
+    backwardMovementOrbital();
+  }
+}
+
+void Camera::forwardMovementFPS() {
   glm::vec3 direction = glm::normalize(lookAt - position);
   position -= direction;
   lookAt -= direction;
 }
 
-void Camera::leftMovement() {
+void Camera::forwardMovementOrbital() {
+  glm::vec3 direction = glm::normalize(lookAt - position);
+  position -= direction;
+}
+
+void Camera::forwardMovement() {
+  if(type == FPS) {
+    forwardMovementFPS();
+  } else {
+    forwardMovementOrbital();
+  }
+}
+
+void Camera::leftMovementFPS() {
   glm::vec3 direction = glm::normalize(lookAt - position);
   glm::vec3 right = glm::normalize(glm::cross(up, direction));
   position -= right;
   lookAt -= right;
 }
 
-void Camera::rightMovement() {
+void Camera::leftMovementOrbital() {
+  glm::vec3 direction = glm::normalize(lookAt - position);
+  glm::vec3 right = glm::normalize(glm::cross(up, direction));
+  lookAt -= right;
+}
+
+void Camera::leftMovement() {
+  if(type == FPS) {
+    leftMovementFPS();
+  } else {
+    leftMovementOrbital();
+  }
+}
+
+void Camera::rightMovementFPS() {
   glm::vec3 direction = glm::normalize(lookAt - position);
   glm::vec3 right = glm::normalize(glm::cross(up, direction));
   position += right;
   lookAt += right;
 }
 
-void Camera::upMovement() {
+void Camera::rightMovementOrbital() {
+  glm::vec3 direction = glm::normalize(lookAt - position);
+  glm::vec3 right = glm::normalize(glm::cross(up, direction));
+  lookAt += right;
+}
+
+void Camera::rightMovement() {
+  if(type == FPS) {
+    rightMovementFPS();
+  } else {
+    rightMovementOrbital();
+  }
+}
+
+void Camera::upMovementFPS() {
   glm::vec3 direction = glm::normalize(lookAt - position);
   glm::vec3 right = glm::normalize(glm::cross(up, direction));
   glm::vec3 up = glm::normalize(glm::cross(direction, right));
   position += up;
   lookAt += up;
 }
 
-void Camera::downMovement() {
+void Camera::upMovementOrbital() {
+  glm::vec3 direction = glm::normalize(lookAt - position);
+  glm::vec3 right = glm::normalize(glm::cross(up, direction));
+  glm::vec3 up = glm::normalize(glm::cross(direction, right));
+  lookAt += up;
+}
+
+void Camera::upMovement() {
+  if(type == FPS) {
+    upMovementFPS();
+  } else {
+    upMovementOrbital();
+  }
+}
+
+void Camera::downMovementFPS() {
   glm::vec3 direction = glm::normalize(lookAt - position);
   glm::vec3 right = glm::normalize(glm::cross(up, direction));
   glm::vec3 up = glm::normalize(glm::cross(direction, right));
   position -= up;
   lookAt -= up;
 }
 
+void Camera::downMovementOrbital() {
+  glm::vec3 direction = glm::normalize(lookAt - position);
+  glm::vec3 right = glm::normalize(glm::cross(up, direction));
+  glm::vec3 up = glm::normalize(glm::cross(direction, right));
+  lookAt -= up;
+}
+
+void Camera::downMovement() {
+  if(type == FPS) {
+    downMovementFPS();
+  } else {
+    downMovementOrbital();
+
+  }
+}
+
 

engine/src/group.cpp

@@ -69,7 +69,6 @@ void Group::drawGroup(bool lights, const Frustsum& frustsum) {
     }
 
     if(model.bounding_sphere.isInsideFrustsum(frustsum, matrix)) {
-      std::cout << model.filename << std::endl;
       model.drawModel();
     }
   }

engine/src/main.cpp

@@ -180,16 +180,20 @@ void processNormalKeys(unsigned char key, int x, int y) {
       }
       break;
     case 'r':
-      cameraAngle = 0;
-      cameraAngleY = 0;
-      zoom = 1.0f;
+      camera = c.camera;
       break;
-    case 'o':
-      zoom -= value;
+    case 'w':
+      camera.upMovement();
       break;
-    case 'i':
-      zoom += value;
+    case 's':
+      camera.downMovement();
       break;
+    case 't':
+      if(camera.type == ORBITAL) {
+        camera.type = FPS;
+      } else {
+        camera.type = ORBITAL;
+      }
     case 'c':
       if (wireframe) {
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);