Added a RenderQueueFactory that produces a RenderQueueCollection for the Renderer to use.

Still needs more work

include/Engine/Rendering/RenderQueue.h

@@ -82,6 +82,7 @@ struct PointLightJob : RenderJob
 	glm::vec3 SpecularColor = glm::vec3(1, 1, 1);
 	glm::vec3 DiffuseColor = glm::vec3(1, 1, 1);
 	float Radius = 1.f;
+    float Intensity = 0.8f;
 
 	void CalculateHash() override
 	{
@@ -101,18 +102,6 @@ struct FrameJob : SpriteJob
 	}
 };
 
-struct WaterParticleJob : RenderJob
-{
-	glm::vec3 Position;
-	glm::vec4 Color;
-	glm::mat4 ModelMatrix;
-
-	void CalculateHash() override
-	{
-		Hash = 0;
-	}
-};
-
 class RenderQueue
 {
 public:
@@ -154,25 +143,22 @@ private:
 
 struct RenderQueueCollection
 {
-	RenderQueue Deferred;
 	RenderQueue Forward;
 	RenderQueue Lights;
-	RenderQueue GUI;
+	RenderQueue Sprites;
 
 	void Clear()
 	{
-		Deferred.Clear();
 		Forward.Clear();
 		Lights.Clear();
-		GUI.Clear();
+        Sprites.Clear();
 	}
 
 	void Sort()
 	{
-		Deferred.Sort();
 		Forward.Sort();
 		Lights.Sort();
-		GUI.Sort();
+        Sprites.Sort();
 	}
 };
 

include/Engine/Rendering/RenderQueueFactory.h

@@ -0,0 +1,29 @@
+#ifndef RenderQueueFactory_h__
+#define RenderQueueFactory_h__
+
+#include "../Core/World.h"
+#include "RenderQueue.h"
+#include "../Core/ResourceManager.h"
+#include "Model.h"
+#include "../GLM.h"
+
+class RenderQueueFactory
+{
+public:
+    RenderQueueFactory();
+    void Update(World* world);
+
+    
+    RenderQueueCollection RenderQueues() const { return m_RenderQueues; }
+private:
+    RenderQueueCollection m_RenderQueues;
+
+    void FillModels(World* world, RenderQueue* renderQueue);
+    void FillSprites(World* world, RenderQueue* renderQueue);
+    void FillLights(World* world, RenderQueue* renderQueue);
+
+    glm::mat4 ModelMatrix(World* world, EntityID entity);
+    glm::vec3 GetAbsolutePosition(World* world, ComponentWrapper transformComponent);
+};
+
+#endif

include/Engine/Rendering/Renderer.h

@@ -19,7 +19,6 @@ public:
 
 private:
 	//----------------------Variables----------------------//
-	RenderQueueCollection m_TempRQ;
 	Texture* m_ErrorTexture;
 	Texture* m_WhiteTexture;
 	float m_CameraMoveSpeed;
@@ -31,11 +30,6 @@ private:
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
-    //Temporary
-    Model* m;
-    Model* m2;
-    Model* m3;
-    Model* MapModel;
 
     
     std::unordered_map<glm::vec2, const Model*> m_PickingColorsToModels;
@@ -45,12 +39,9 @@ private:
 	void InitializeShaders();
     void InitializeTextures();
     void InitializeFrameBuffers();
-	//TODO: Renderer: Remove ModelsToDraw from Renderer.
+    //TODO: Renderer: Get InputUpdate out of renderer
-	void ModelsToDraw();
-    //TODO: Renderer: Get EnqueueModel and InputUpdate out of renderer
-	void EnqueueModel(Model* model);
 	void InputUpdate(double dt);
-    void PickingPass();
+    void PickingPass(RenderQueueCollection& rq);
     void DrawScreenQuad(GLuint textureToDraw);
     void DrawScene(RenderQueueCollection& rq);
 

include/Game/Game.h

@@ -8,6 +8,7 @@
 #include "Core/InputManager.h"
 #include "GUI/Frame.h"
 #include "Core/World.h"
+#include "Rendering/RenderQueueFactory.h"
 
 class Game
 {
@@ -26,6 +27,7 @@ private:
 	InputManager* m_InputManager;
 	GUI::Frame* m_FrameStack;
     World* m_World;
+    RenderQueueFactory* m_RenderQueueFactory;
 };
 
 #endif

include/Game/HardcodedTestWorld.h

@@ -73,6 +73,13 @@ private:
                     std::make_tuple(sizeof(glm::quat), "Orientation", glm::quat()),
                     std::make_tuple(sizeof(glm::vec3), "Scale", glm::vec3(1.f, 1.f, 1.f))
                 } 
+            },
+            {
+                "Model",
+                {
+                    std::make_tuple(sizeof(std::string), "ModelFile", std::string("Unnamed")),
+                    std::make_tuple(sizeof(glm::vec4), "Color", glm::vec4(1.f, 1.f, 1.f, 1.f)),
+                }
             }
         };
 
@@ -106,19 +113,71 @@ private:
 
     void createTestEntities()
     {
-        EntityID e = CreateEntity();
+        {
-        AttachComponent(e, "Test");
+            EntityID e = CreateEntity();
-        AttachComponent(e, "Debug");
+            AttachComponent(e, "Test");
-        AttachComponent(e, "Transform");
+            AttachComponent(e, "Debug");
-        ComponentWrapper testComponent = GetComponent(e, "Test");
+            AttachComponent(e, "Transform");
-        int testValue = testComponent["TestInteger"];
+            ComponentWrapper testComponent = GetComponent(e, "Test");
-        float testFloat = testComponent["TestFloat"];
+            int testValue = testComponent["TestInteger"];
-        ComponentWrapper debugComponent = GetComponent(e, "Debug");
+            float testFloat = testComponent["TestFloat"];
-        std::string name = debugComponent["Name"];
+            ComponentWrapper debugComponent = GetComponent(e, "Debug");
-        glm::vec3 pickingColor = debugComponent["PickingColor"];
+            std::string name = debugComponent["Name"];
-        ComponentWrapper testTransform = GetComponent(e, "Transform");
+            glm::vec3 pickingColor = debugComponent["PickingColor"];
-        glm::vec3 pos = testTransform["Position"];
+            ComponentWrapper testTransform = GetComponent(e, "Transform");
-        glm::quat ori = testTransform["Orientation"];
+            glm::vec3 pos = testTransform["Position"];
-        glm::vec3 scale = testTransform["Scale"];
+            glm::quat ori = testTransform["Orientation"];
+            glm::vec3 scale = testTransform["Scale"];
+        }
+
+        {
+            EntityID entityTranslationWidget = CreateEntity();
+            AttachComponent(entityTranslationWidget, "Transform");
+            AttachComponent(entityTranslationWidget, "Model");
+            ComponentWrapper testTransform = GetComponent(entityTranslationWidget, "Transform");
+            glm::vec3 pos = testTransform["Position"];
+            glm::quat ori = testTransform["Orientation"];
+            glm::vec3 scale = testTransform["Scale"];
+            ComponentWrapper testModel = GetComponent(entityTranslationWidget, "Model");
+            std::string file = testModel["ModelFile"];
+            file = "Models/TranslationWidget.obj";
+            testModel["ModelFile"] = file;
+            glm::vec4 col = testModel["Color"];
+        }
+        {
+            EntityID entityScaleWidget = CreateEntity();
+            AttachComponent(entityScaleWidget, "Transform");
+            AttachComponent(entityScaleWidget, "Model");
+            ComponentWrapper testTransform = GetComponent(entityScaleWidget, "Transform");
+            glm::vec3 pos = testTransform["Position"];
+            pos = glm::vec3(-1.5f, 0.f, 0.f);
+            testTransform["Position"] = pos;
+            glm::quat ori = testTransform["Orientation"];
+            glm::vec3 scale = testTransform["Scale"];
+            ComponentWrapper testModel = GetComponent(entityScaleWidget, "Model");
+            std::string file = testModel["ModelFile"];
+            file = "Models/ScaleWidget.obj";
+            testModel["ModelFile"] = file;
+            glm::vec4 col = testModel["Color"];
+        }
+        {
+            EntityID entityRotationWidget = CreateEntity();
+            AttachComponent(entityRotationWidget, "Transform");
+            AttachComponent(entityRotationWidget, "Model");
+            ComponentWrapper testTransform = GetComponent(entityRotationWidget, "Transform");
+            glm::vec3 pos = testTransform["Position"];
+            pos = glm::vec3(1.5f, 0.f, 0.f);
+            testTransform["Position"] = pos;
+            glm::quat ori = testTransform["Orientation"];
+            glm::vec3 scale = testTransform["Scale"];
+            ComponentWrapper testModel = GetComponent(entityRotationWidget, "Model");
+            std::string file = testModel["ModelFile"];
+            file = "Models/RotationWidget.obj";
+            testModel["ModelFile"] = file;
+            glm::vec4 col = testModel["Color"];
+        }
+
+
+
     }
 };

src/Engine/Rendering/RenderQueueFactory.cpp

@@ -0,0 +1,70 @@
+#include "Rendering/RenderQueueFactory.h"
+
+
+RenderQueueFactory::RenderQueueFactory()
+{
+    m_RenderQueues = RenderQueueCollection();
+}
+
+void RenderQueueFactory::Update(World* world)
+{
+    m_RenderQueues.Clear();
+    FillModels(world, &m_RenderQueues.Forward);
+    FillSprites(world, &m_RenderQueues.Sprites);
+    FillLights(world, &m_RenderQueues.Lights);
+}
+
+glm::mat4 RenderQueueFactory::ModelMatrix(World* world, EntityID entity)
+{
+    //should really return absolute model matrix based on parents position, scale and orientation
+    //GetAbsolutePosition(World* world, ComponentWrapper transformComponent)
+
+    ComponentWrapper transformComponent = world->GetComponent(entity, "Transform");
+    glm::vec3 position = transformComponent["Position"];
+    glm::vec3 scale = transformComponent["Scale"];
+    glm::quat oritentation = transformComponent["Orientation"];
+
+    glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(oritentation) * glm::scale(scale);
+    return modelMatrix;
+}
+
+glm::vec3 GetAbsolutePosition(World* world, ComponentWrapper transformComponent)
+{
+  //  positionComponent.EntityID
+    return glm::vec3();
+}
+
+void RenderQueueFactory::FillModels(World* world, RenderQueue* renderQueue)
+{
+   for(auto& modelC : world->GetComponents("Model")) {
+       ModelJob job;
+       std::string modelFile = modelC["ModelFile"];
+       glm::vec4 color = modelC["Color"];
+       Model* model = ResourceManager::Load<Model>(modelFile);
+
+       for (auto texGroup : model->TextureGroups) {
+           job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
+           job.DiffuseTexture = texGroup.Texture.get();
+           job.NormalTexture = texGroup.NormalMap.get();
+           job.SpecularTexture = texGroup.SpecularMap.get();
+           job.Model = model;
+           job.StartIndex = texGroup.StartIndex;
+           job.EndIndex = texGroup.EndIndex;
+           job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
+           job.Color = color;
+
+           renderQueue->Add(job);
+       }
+   }
+}
+
+void RenderQueueFactory::FillSprites(World* world, RenderQueue* renderQueue)
+{
+    
+}
+
+void RenderQueueFactory::FillLights(World* world, RenderQueue* renderQueue)
+{
+
+}
+

src/Engine/Rendering/Renderer.cpp

@@ -15,7 +15,11 @@ void Renderer::Initialize()
 	InitializeShaders();
     InitializeTextures();
     InitializeFrameBuffers();
-	ModelsToDraw();
+
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+    m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
+    m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");
 }
 
 void Renderer::InitializeWindow()
@@ -78,54 +82,6 @@ void Renderer::InitializeShaders()
 
 }
 
-void Renderer::ModelsToDraw()
-{
-    
-	m = ResourceManager::Load<Model>("Models/ScaleWidget.obj");
-	EnqueueModel(m);
-	m2 = ResourceManager::Load<Model>("Models/TranslationWidget.obj");
-	EnqueueModel(m2);
-	m3 = ResourceManager::Load<Model>("Models/RotationWidget.obj");
-	EnqueueModel(m3);
-    
-	m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");
-	EnqueueModel(m_UnitSphere);
-    m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
-
-    MapModel = ResourceManager::Load<Model>("Models/DummyScene.obj");
-    EnqueueModel(MapModel);
-}
-
-void Renderer::EnqueueModel(Model* model)
-{
-	for (auto texGroup : model->TextureGroups)
-	{
-		ModelJob job;
-		job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
-		job.DiffuseTexture = texGroup.Texture.get();
-		job.NormalTexture = texGroup.NormalMap.get();
-		job.SpecularTexture = texGroup.SpecularMap.get();
-		job.Model = model;
-		job.StartIndex = texGroup.StartIndex;
-		job.EndIndex = texGroup.EndIndex;
-		job.ModelMatrix =  model->m_Matrix;
-		//job.ModelMatrix = modelMatrix * model->m_Matrix; TODO: Render: Make sure modelMatrix work
-		//job.Color = modelComponent->Color; TODO: Render: Take color from kd in .mtl or a value from modelcomponent.
-		job.Color = glm::vec4(1.f);
-
-		//TODO: Render: Skeleton animations
-		//if (model->m_Skeleton != nullptr && animationComponent != nullptr) {
-		//	job.Skeleton = model->m_Skeleton;
-		//	job.AnimationName = animationComponent->Name;
-		//	job.AnimationTime = animationComponent->Time;
-		//	job.NoRootMotion = animationComponent->NoRootMotion;
-		//}
-
-		m_TempRQ.Forward.Add(job);
-	}
-}
-
 void Renderer::InputUpdate(double dt)
 {
 	glm::vec3 m_Position = m_Camera->Position();
@@ -202,15 +158,16 @@ void Renderer::InputUpdate(double dt)
 void Renderer::Update(double dt)
 {
 	InputUpdate(dt);
+    
 }
 
 void Renderer::Draw(RenderQueueCollection& rq)
 {
     //TODO: Renderer: Kanske borde vara längst upp i update.
-    PickingPass();
+    PickingPass(rq);
     DrawScreenQuad(m_PickingTexture);
     
-   // DrawScene(rq);
+    DrawScene(rq);
 	glfwSwapBuffers(m_Window);
 }
 
@@ -227,14 +184,14 @@ void Renderer::DrawScene(RenderQueueCollection& rq)
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     //TODO: Render: Add code for more jobs than modeljobs.
-    for (auto &job : m_TempRQ.Forward) {
+    for (auto &job : rq.Forward) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
         if (modelJob) {
             GLuint ShaderHandle = m_BasicForwardProgram.GetHandle();
 
             m_BasicForwardProgram.Bind();
             //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
-            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(glm::mat4(1)));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Camera->ProjectionMatrix()));
 
@@ -256,7 +213,7 @@ void Renderer::DrawScene(RenderQueueCollection& rq)
     }
 }
 
-void Renderer::PickingPass()
+void Renderer::PickingPass(RenderQueueCollection& rq)
 {
     m_PickingBuffer.Bind();
 
@@ -274,7 +231,7 @@ void Renderer::PickingPass()
     GLuint ShaderHandle = m_PickingProgram.GetHandle();
     m_PickingProgram.Bind();
 
-    for (auto &job : m_TempRQ.Forward) {
+    for (auto &job : rq.Forward) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {
@@ -283,7 +240,7 @@ void Renderer::PickingPass()
 
             //Render picking stuff
             //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
-            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(glm::mat4(1)));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Camera->ProjectionMatrix()));
             glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(pickColor));

src/Game/Game.cpp

@@ -13,6 +13,8 @@ Game::Game(int argc, char* argv[])
 	// Create the core event broker
 	m_EventBroker = new EventBroker();
 
+    m_RenderQueueFactory = new RenderQueueFactory();
+
 	// Create the renderer
 	m_Renderer = new Renderer();
 	m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
@@ -56,9 +58,9 @@ void Game::Tick()
 	m_Renderer->Update(dt);
 	m_EventBroker->Swap();
 
-	//TODO: Render: This is not used, but will be used later when we dont add models to RQ in renderer.
+    m_RenderQueueFactory->Update(m_World);
-	RenderQueueCollection rq;
+
-	m_Renderer->Draw(rq);
+	m_Renderer->Draw(m_RenderQueueFactory->RenderQueues());
 
 	m_EventBroker->Swap();
 	m_EventBroker->Clear();