Camera Switch event now working, Camera models Rotation still bugged

include/Engine/Rendering/RenderSystem.cpp

@@ -1,16 +1,52 @@
-#include "RenderSystem.h"
+#include "Rendering/RenderSystem.h"
+#include "Rendering/DebugCameraInputController.h"
 
 RenderSystem::RenderSystem(EventBroker* eventBrokerer, RenderQueueCollection* renderQueues)
     :ImpureSystem(eventBrokerer)
 {
     m_RenderQueues = renderQueues;
     Initialize();
+    EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &RenderSystem::OnSetCamera);
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &RenderSystem::OnInputCommand);
 }
 
 
+bool RenderSystem::OnSetCamera(const Events::SetCamera &event)
+{
+    m_CurrentCamera = event.Entity;
+    return true;
+}
+
+void RenderSystem::SwitchCamera(EntityID entity)
+{
+    m_CurrentCamera = entity;
+    m_SwitchCamera = false;
+    LOG_INFO("Switched to camera %i", m_CurrentCamera);
+}
+
 void RenderSystem::Initialize()
 {
+    
+}
 
+void RenderSystem::UpdateViewMatrix(ComponentWrapper& cameraTransform)
+{
+    glm::quat orientation = cameraTransform["Orientation"];
+    glm::vec3 position = cameraTransform["Position"];
+
+    m_ViewMatrix = glm::toMat4(glm::inverse(orientation)) * glm::translate(-position);
+}
+
+void RenderSystem::UpdateProjectionMatrix(ComponentWrapper& cameraComponent)
+{
+    double fov = (double&)cameraComponent["FOV"];
+    double aspectRatio = (double&)cameraComponent["AspectRatio"];
+    double nearClip = (double&)cameraComponent["NearClip"];
+    double farClip = (double&)cameraComponent["FarClip"];
+
+    double fovY = atan(tan(glm::radians(fov)/2.0) * aspectRatio) * 2.0;
+    m_ProjectionMatrix = glm::perspective(fovY, aspectRatio, nearClip, farClip);
+    
 }
 
 glm::vec3 RenderSystem::AbsolutePosition(World* world, EntityID entity)
@@ -57,6 +93,7 @@ glm::vec3 RenderSystem::AbsoluteScale(World* world, EntityID entity)
     return scale;
 }
 
+
 glm::mat4 RenderSystem::ModelMatrix(World* world, EntityID entity)
 {
     glm::vec3 position = AbsolutePosition(world, entity);
@@ -101,10 +138,10 @@ void RenderSystem::FillModels(World* world, RenderQueue* renderQueue)
                 job.Model = model;
                 job.StartIndex = texGroup.StartIndex;
                 job.EndIndex = texGroup.EndIndex;
-                job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
+                job.Matrix = m_ProjectionMatrix * m_ViewMatrix * (model->m_Matrix * ModelMatrix(world, modelC.EntityID));
                 job.Color = color;
-
                 job.Entity = modelC.EntityID;
+
                 job.Depth = 10.f; //insert real viewspace depth here
 
                 renderQueue->Add(job);
@@ -117,24 +154,79 @@ void RenderSystem::FillModels(World* world, RenderQueue* renderQueue)
                 job.Model = model;
                 job.StartIndex = texGroup.StartIndex;
                 job.EndIndex = texGroup.EndIndex;
-                job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
+                job.Matrix = m_ProjectionMatrix * m_ViewMatrix * (model->m_Matrix * ModelMatrix(world, modelC.EntityID));
                 job.Color = color;
-
-                //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
                 job.Entity = modelC.EntityID;
 
                 renderQueue->Add(job);
             }
-
-
-
         }
     }
 }
 
+bool RenderSystem::OnInputCommand(const Events::InputCommand& e)
+{
+    if (e.Command == "SwitchCamera" && e.Value > 0) {
+        m_SwitchCamera = true;
+        return true;
+    } else {
+        return false;
+    }
+}
+
 
 void RenderSystem::Update(World* world, double dt)
 {
+    m_EventBroker->Process<RenderSystem>();
+    static DebugCameraInputController<RenderSystem> firstPersonInputController(m_EventBroker, -1);
+
+    if (m_SwitchCamera) {
+        auto cameras = world->GetComponents("Camera");
+
+        if (cameras != nullptr) {
+            for (auto it = cameras->begin(); it != cameras->end(); it++) {
+                if ((*it).EntityID == m_CurrentCamera) {
+                    it++;
+                    if (it != cameras->end()) {
+                        SwitchCamera((*it).EntityID);
+                    } else {
+                        SwitchCamera((*cameras->begin()).EntityID);
+                    }
+                    break;
+                }
+            }
+            ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
+            ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
+            
+            firstPersonInputController.SetOrientation((glm::quat)cameraTransform["Orientation"]);
+            firstPersonInputController.SetPosition((glm::vec3)cameraTransform["Position"]);
+        }
+    }
+    
+    if(world->HasComponent(m_CurrentCamera, "Camera") && world->HasComponent(m_CurrentCamera, "Transform")) {
+
+        ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
+        ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
+
+        firstPersonInputController.Update(dt);
+        (glm::quat&)cameraTransform["Orientation"] = firstPersonInputController.Orientation();
+        (glm::vec3&)cameraTransform["Position"] = firstPersonInputController.Position();
+
+       
+        UpdateProjectionMatrix(cameraComponent);
+        UpdateViewMatrix(cameraTransform);
+    } else {
+        m_ProjectionMatrix = glm::perspective(glm::radians(40.f), 1.77f, 0.05f, 5000.f);
+        m_ViewMatrix = glm::mat4();
+
+        auto cameras = world->GetComponents("Camera");
+
+        if (cameras != nullptr) {
+            ComponentWrapper& cameraC = *cameras->begin();
+            m_CurrentCamera = cameraC.EntityID;
+        }
+    }
+
     m_RenderQueues->Clear();
     FillModels(world, &m_RenderQueues->Forward);
 }