One hell of a GUI interface (minus graphical)

"how does this even work lol"

src/Camera.cpp

@@ -1,10 +1,9 @@
 #include "PrecompiledHeader.h"
 #include "Camera.h"
 
-Camera::Camera(float yFOV, float aspectRatio, float nearClip, float farClip)
+Camera::Camera(float yFOV, float nearClip, float farClip)
 {
 	m_FOV = yFOV;
-	m_AspectRatio = aspectRatio;
 	m_NearClip = nearClip;
 	m_FarClip = farClip;
 
@@ -31,14 +30,14 @@ Camera::Camera(float yFOV, float aspectRatio, float nearClip, float farClip)
 //	return orientation;
 //}
 
-void Camera::Position(glm::vec3 val)
+void Camera::SetPosition(glm::vec3 val)
 {
 	m_Position = val;
 	UpdateViewMatrix();
 }
 
 
-void Camera::Orientation(glm::quat val)
+void Camera::SetOrientation(glm::quat val)
 {
 	m_Orientation = val;
 	UpdateViewMatrix();
@@ -61,17 +60,17 @@ void Camera::UpdateViewMatrix()
 	m_ViewMatrix = glm::toMat4(glm::inverse(m_Orientation)) * glm::translate(-m_Position);
 }
 
-void Camera::FOV(float val)
+void Camera::SetFOV(float val)
 {
 	m_FOV = val;
 }
 
-void Camera::NearClip(float val)
+void Camera::SetNearClip(float val)
 {
 	m_NearClip = val;
 }
 
-void Camera::FarClip(float val)
+void Camera::SetFarClip(float val)
 {
 	m_FarClip = val;
 }

src/Engine.h

@@ -7,26 +7,26 @@
 #include "Renderer.h"
 #include "InputManager.h"
 #include "GUI/Frame.h"
-#include "GameWorld.h"
+#include "GUI/GameFrame.h"
 
 class Engine
 {
 public:
 	Engine(int argc, char* argv[])
 	{
-		m_ResourceManager = std::make_shared<ResourceManager>();
-
 		m_EventBroker = std::make_shared<EventBroker>();
+		m_ResourceManager = std::make_shared<ResourceManager>();
 
 		m_Renderer = std::make_shared<Renderer>();
 		m_Renderer->Initialize();
 
 		m_InputManager = std::make_shared<InputManager>(m_Renderer->GetWindow(), m_EventBroker);
 
-		m_FrameStack = std::make_shared<GUI::Frame>(m_EventBroker, m_Renderer);
+		m_FrameStack = new GUI::Frame(m_EventBroker, m_ResourceManager); 
+		new GUI::GameFrame(m_FrameStack, "GameFrame");
 
-		m_World = std::make_shared<GameWorld>(m_EventBroker, m_Renderer);
-		m_World->Initialize();
+		//m_World = std::make_shared<GameWorld>(m_EventBroker, m_ResourceManager);
+		//m_World->Initialize();
 
 		m_LastTime = glfwGetTime();
 	}
@@ -40,8 +40,8 @@ public:
 		m_LastTime = currentTime;
 
 		m_InputManager->Update(dt);
-		m_World->Update(dt);
-		m_Renderer->Draw(dt);
+		m_FrameStack->DrawLayered(m_Renderer);
+		
 		m_EventBroker->Clear();
 
 		glfwPollEvents();
@@ -52,9 +52,9 @@ private:
 	std::shared_ptr<EventBroker> m_EventBroker;
 	std::shared_ptr<Renderer> m_Renderer;
 	std::shared_ptr<InputManager> m_InputManager;
-	std::shared_ptr<GUI::Frame> m_FrameStack;
+	GUI::Frame* m_FrameStack;
 	// TODO: This should ultimately live in GameFrame
-	std::shared_ptr<GameWorld> m_World;
+	//std::shared_ptr<GameWorld> m_World;
 
 	double m_LastTime;
 };

src/GUI/Frame.h

@@ -31,17 +31,29 @@ public:
 		, ResourceManager(resourceManager)
 		, Rectangle()
 		, m_Name("UIParent")
-	{ Initialize(); }
+		, m_Layer(0)
+	{ }
+
 	// Create a frame as a child
-	Frame(std::shared_ptr<Frame> parent, std::string name)
+	Frame(Frame* parent, std::string name)
 		: Rectangle(static_cast<Rectangle>(*parent)) // Clone parent rectangle using copy constructor
 		, m_Name(name)
-	{ SetParent(parent); Initialize(); }
+		, m_Layer(0)
+	{ SetParent(std::shared_ptr<Frame>(parent)); }
+
+
+	::RenderQueue RenderQueue;
 
-	virtual void Initialize() { }
 	std::shared_ptr<Frame> Parent() const { return m_Parent; }
 	void SetParent(std::shared_ptr<Frame> parent) 
-	{ 
+	{
+		if (parent == nullptr)
+		{
+			LOG_ERROR("Failed to create frame \"%s\": Invalid parent", m_Name.c_str());
+			return;
+		}
+
+		m_Layer = parent->Layer() + 1;
 		parent->AddChild(std::shared_ptr<Frame>(this));
 		m_Parent = parent;
 		EventBroker = parent->EventBroker;
@@ -50,25 +62,56 @@ public:
 
 	void AddChild(std::shared_ptr<Frame> child)
 	{
-		m_Children.push_back(std::make_pair(child->Name(), child));
+		m_Children[child->m_Layer].insert(std::make_pair(child->Name(), child));
+		if (m_Parent)
+		{
+			m_Parent->AddChild(child);
+		}
 	}
 
 	typedef std::map<std::string, std::shared_ptr<Frame>>::const_iterator FrameChildrenIterator;
-	FrameChildrenIterator begin()
-	{
-		return m_Children.begin();
-	}
-	FrameChildrenIterator end()
-	{
-		return m_Children.end();
-	}
 
 	std::string Name() const { return m_Name; }
 	void SetName(std::string val) { m_Name = val; }
+	int Layer() const { return m_Layer; }
+
+	int Left() const override
+	{ 
+		if (m_Parent)
+			return m_Parent->Left() + X;
+		else
+			return X; 
+	}
+	int Right() const override
+	{ 
+		if (m_Parent)
+			return m_Parent->Right() + X + Width;
+		else
+			return X + Width; 
+	}
+	int Top() const override
+	{ 
+		if (m_Parent)
+			return m_Parent->Top() + Y;
+		else
+			return Y;
+	}
+	int Bottom() const override 
+	{
+		if (m_Parent)
+			return m_Parent->Bottom() + Y + Height;
+		else
+			return Y + Height;
+	}
+
+	Rectangle AbsoluteRectangle()
+	{
+		return Rectangle(Left(), Right(), Width, Height);
+	}
 
 	virtual void Update(double dt)
 	{
-		for (auto &pair : m_Children)
+		for (auto &pair : m_Children[m_Layer + 1])
 		{
 			pair.second->Update(dt);
 		}
@@ -76,31 +119,35 @@ public:
 
 	void DrawLayered(std::shared_ptr<Renderer> renderer)
 	{
-		renderer->SetViewport(GetLeft(), GetTop(), GetRight(), GetBottom());
+		// Draw ourselves
+		renderer->SetViewport(AbsoluteRectangle());
 		this->Draw(renderer);
-		renderer->Draw();
 
-		for (auto &pair : m_Children)
+		// Draw children
+		for (auto &pairLayer : m_Children)
 		{
-			pair.second->Draw(renderer);
+			auto children = pairLayer.second;
+			for (auto &pairChild : children)
+			{
+				auto child = pairChild.second;
+				renderer->SetViewport(child->AbsoluteRectangle());
+				child->Draw(renderer);
+			}
 		}
 	}
 
-	virtual void Draw(std::shared_ptr<Renderer> renderer)
-	{
-		renderer->SetViewport(GetLeft(), GetTop(), GetRight(), GetBottom());
-		renderer->Draw();
-
-		
-	}
+	virtual void Draw(std::shared_ptr<Renderer> renderer) { }
 
 protected:
 	std::shared_ptr<::EventBroker> EventBroker;
 	std::shared_ptr<::ResourceManager> ResourceManager;
+
 	std::string m_Name;
+	int m_Layer;
 	
 	std::shared_ptr<Frame> m_Parent;
-	std::multimap<std::string, std::shared_ptr<Frame>> m_Children; // name -> frame
+	typedef std::multimap<std::string, std::shared_ptr<Frame>> Children_t; // name -> frame
+	std::map<int, Children_t> m_Children; // layer -> Children_t
 
 };
 

src/GUI/GameFrame.h

@@ -0,0 +1,45 @@
+#ifndef GUI_GameFrame_h__
+#define GUI_GameFrame_h__
+
+#include "GUI/Frame.h"
+#include "GUI/WorldFrame.h"
+#include "GUI/Viewport.h"
+
+#include "GameWorld.h"
+
+namespace GUI
+{
+
+class GameFrame : public Frame
+{
+public:
+	GameFrame(Frame* parent, std::string name)
+		: Frame(parent, name)
+	{
+		m_World = std::make_shared<GameWorld>(EventBroker, ResourceManager);
+		m_World->Initialize();
+
+		auto worldFrame = new WorldFrame(this, "GameWorldFrame", m_World);
+		{
+			new Viewport(worldFrame, "Viewport1", m_World);
+			new Viewport(worldFrame, "Viewport2", m_World);
+		}
+	}
+
+	void Update(double dt) override
+	{
+		
+	}
+
+	void Draw(std::shared_ptr<Renderer> renderer) override
+	{
+		
+	}
+
+private:
+	std::shared_ptr<GameWorld> m_World;
+};
+
+}
+
+#endif // GUI_GameFrame_h__

src/GUI/TextureFrame.h

@@ -13,28 +13,19 @@ public:
 	TextureFrame(std::shared_ptr<Frame> parent, std::string name)
 		: Frame(parent, name) { }
 
-	void Update(double dt) override
-	{
-		Frame::Update(dt);
-	}
-
 	void Draw(std::shared_ptr<Renderer> renderer) override
 	{
 		if (m_Texture == nullptr)
 			return;
 
-		RenderQueue<SpriteJob> rq;
-
-		auto textureAsset = ResourceManager->Load<Texture>("Texture", m_Texture);
-
+		RenderQueue.Clear();
 		SpriteJob job;
+		job.TextureID = m_Texture->ResourceID;
+		job.Texture = *m_Texture;
+		RenderQueue.Add(job);
 
-		Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-		glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(absoluteTransform->Orientation).z, glm::vec3(0, 0, -1));
-		glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position);
-		*glm::toMat4(orientation2D)
-			* glm::scale(absoluteTransform.Scale);
-		EnqueueSprite(spriteQueue, textureAsset, modelMatrix);
+		renderer->SetCamera(nullptr);
+		renderer->Draw(RenderQueue);
 	}
 
 	std::shared_ptr<::Texture> Texture() const { return m_Texture; }

src/GUI/Viewport.h

@@ -5,6 +5,7 @@
 
 #include "GUI/Frame.h"
 #include "World.h"
+#include "Systems/TransformSystem.h"
 #include "Components/Transform.h"
 #include "Components/Camera.h"
 #include "RenderQueue.h"
@@ -16,10 +17,12 @@ namespace GUI
 class Viewport : public Frame
 {
 public:
-	Viewport(std::shared_ptr<Frame> parent, std::string name, std::shared_ptr<World> world)
+	Viewport(Frame* parent, std::string name, std::shared_ptr<World> world)
 		: Frame(parent, name)
 		, m_World(world)
-	{ }
+	{
+			m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
+	}
 
 	EntityID CameraEntity() const { return m_CameraEntity; }
 	void SetCameraEntity(EntityID cameraEntity) 
@@ -35,37 +38,37 @@ public:
 		m_Camera = std::make_shared<Camera>(cameraComponent->FOV, cameraComponent->NearClip, cameraComponent->FarClip);
 	}
 
-	void Initialize() override
-	{
-
-	}
 
 	void Update(double dt) override
 	{
 		auto transformComponent = m_World->GetComponent<Components::Transform>(m_CameraEntity);
 		if (!transformComponent)
 			return;
+		
 		auto cameraComponent = m_World->GetComponent<Components::Camera>(m_CameraEntity);
 		if (!cameraComponent)
 			return;
 
+		Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(m_CameraEntity);
+
 		m_Camera->SetFOV(cameraComponent->FOV);
 		m_Camera->SetNearClip(cameraComponent->NearClip);
 		m_Camera->SetFarClip(cameraComponent->FarClip);
+		m_Camera->SetPosition(absoluteTransform.Position);
+		m_Camera->SetOrientation(absoluteTransform.Orientation);
 	}
 
 	void Draw(std::shared_ptr<Renderer> renderer) override
 	{
 		renderer->SetCamera(m_Camera);
-
-		Frame::Draw(renderer);
+		renderer->Draw(m_Parent->RenderQueue);
 	}
 
 private:
 	std::shared_ptr<World> m_World;
+	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
 	std::shared_ptr<Camera> m_Camera;
 	EntityID m_CameraEntity;
-	
 };
 
 }

src/GUI/WorldFrame.h

@@ -15,129 +15,123 @@
 namespace GUI
 {
 
-	class WorldFrame : public Frame
+class WorldFrame : public Frame
+{
+public:
+	WorldFrame(Frame* parent, std::string name, std::shared_ptr<World> world)
+		: Frame(parent, name)
+		, m_World(world)
 	{
-	public:
-		WorldFrame(std::shared_ptr<Frame> parent, std::string name, std::shared_ptr<World> world)
-			: Frame(parent, name)
-			, m_World(world)
-		{ }
+		EVENT_SUBSCRIBE_MEMBER(m_ESetViewportCamera, &WorldFrame::OnSetViewportCamera);
+		m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
+	}
 
-		void Initialize() override
+	void Update(double dt) override
+	{
+		m_World->Update(dt);
+	}
+
+	void Draw(std::shared_ptr<Renderer> renderer) override
+	{
+		RenderQueue.Clear();
+
+		for (auto &pair : *m_World->GetEntities())
 		{
-			EVENT_SUBSCRIBE_MEMBER(m_ESetViewportCamera, &WorldFrame::OnSetViewportCamera);
+			EntityID entity = pair.first;
 
-			m_World->Initialize();
-		}
+			auto transform = m_World->GetComponent<Components::Transform>(entity);
+			if (!transform)
+				continue;
 
-		void Update(double dt) override
-		{
-			m_World->Update(dt);
-			m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
-		}
-
-		void Draw(std::shared_ptr<Renderer> renderer) override
-		{
-			renderer->Flush();
-
-			RenderQueue<ModelJob> modelQueue;
-			RenderQueue<SpriteJob> spriteQueue;
-			for (auto &pair : *m_World->GetEntities())
+			auto modelComponent = m_World->GetComponent<Components::Model>(entity);
+			if (modelComponent)
 			{
-				EntityID entity = pair.first;
-
-				auto transform = m_World->GetComponent<Components::Transform>(entity);
-				if (!transform)
-					continue;
-
-				auto modelComponent = m_World->GetComponent<Components::Model>(entity);
-				if (modelComponent)
+				auto modelAsset = ResourceManager->Load<Model>("Model", modelComponent->ModelFile);
+				if (modelAsset)
 				{
-					auto modelAsset = ResourceManager->Load<Model>("Model", modelComponent->ModelFile);
-					if (modelAsset)
-					{
-						Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-						glm::mat4 modelMatrix = glm::translate(glm::mat4(), absoluteTransform.Position)
-										      * glm::toMat4(absoluteTransform.Orientation)
-											  * glm::scale(absoluteTransform.Scale);
-						EnqueueModel(modelQueue, modelAsset, modelMatrix);
-					}
-				}
-
-				auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
-				if (spriteComponent)
-				{
-					auto textureAsset = ResourceManager->Load<Texture>("Texture", spriteComponent->SpriteFile);
-					if (textureAsset)
-					{
-						Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-						glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(absoluteTransform->Orientation).z, glm::vec3(0, 0, -1));
-						glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position);
-											  * glm::toMat4(orientation2D)
-											  * glm::scale(absoluteTransform.Scale);
-						EnqueueSprite(spriteQueue, textureAsset, modelMatrix);
-					}
-				}
-
-				auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity);
-				if (pointLightComponent)
-				{
-					// TODO: Push lights to renderer
-					// renderer->PushLight(...);
+					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
+					glm::mat4 modelMatrix = glm::translate(glm::mat4(), absoluteTransform.Position)
+										    * glm::toMat4(absoluteTransform.Orientation)
+											* glm::scale(absoluteTransform.Scale);
+					EnqueueModel(modelAsset, modelMatrix);
 				}
 			}
 
-			renderer->PushQueue(rq);
-
-			Frame::Draw(renderer);
-		}
-
-	protected:
-		std::shared_ptr<World> m_World;
-
-	private:
-		EventRelay<Frame, Events::SetViewportCamera> m_ESetViewportCamera;
-		bool OnSetViewportCamera(const Events::SetViewportCamera &event)
-		{
-			auto itpair = m_Children.equal_range(event.ViewportFrame);
-			for (auto it = itpair.first; it != itpair.second; ++it)
+			auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
+			if (spriteComponent)
 			{
-				auto viewportFrame = std::dynamic_pointer_cast<GUI::Viewport>(it->second);
-				if (!viewportFrame)
-					continue;
+				auto textureAsset = ResourceManager->Load<Texture>("Texture", spriteComponent->SpriteFile);
+				if (textureAsset)
+				{
+					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
+					glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(absoluteTransform.Orientation).z, glm::vec3(0, 0, -1));
+					glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position)
+										  * glm::toMat4(orientation2D)
+										  * glm::scale(absoluteTransform.Scale);
+					EnqueueSprite(textureAsset, modelMatrix);
+				}
+			}
 
-				viewportFrame->SetCamera(event.CameraEntity);
+			auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity);
+			if (pointLightComponent)
+			{
+				// TODO: Push lights to renderer
+				// renderer->PushLight(...);
 			}
 		}
+	}
 
-		std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
+protected:
+	std::shared_ptr<World> m_World;
 
-		void EnqueueModel(RenderQueue<ModelJob> &renderQueue, Model* model, glm::mat4 modelMatrix)
+private:
+	EventRelay<Frame, Events::SetViewportCamera> m_ESetViewportCamera;
+	bool OnSetViewportCamera(const Events::SetViewportCamera &event)
+	{
+		// Search next layer for viewports and update cameras
+		auto itpair = m_Children[m_Layer + 1].equal_range(event.ViewportFrame);
+		for (auto it = itpair.first; it != itpair.second; ++it)
 		{
-			for (auto texGroup : model->TextureGroups)
-			{
-				ModelJob job;
-				job.TextureID = texGroup.Texture->ResourceID;
-				job.DiffuseTexture = *texGroup.Texture;
-				job.NormalTexture = *texGroup.NormalMap;
-				job.SpecularTexture = *texGroup.SpecularMap;
-				job.VAO = model->VAO;
-				job.StartIndex = texGroup.StartIndex;
-				job.EndIndex = texGroup.EndIndex;
-				job.ModelMatrix = modelMatrix;
-					
-				renderQueue.Add(job);
-			}
+			auto viewportFrame = std::dynamic_pointer_cast<GUI::Viewport>(it->second);
+			if (!viewportFrame)
+				continue;
+
+			viewportFrame->SetCameraEntity(event.CameraEntity);
 		}
 
-		void EnqueueSprite(RenderQueue<SpriteJob> &renderQueue, Texture* texture, glm::mat4 modelMatrix)
+		return true;
+	}
+
+	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
+
+	void EnqueueModel(Model* model, glm::mat4 modelMatrix)
+	{
+		for (auto texGroup : model->TextureGroups)
 		{
-			SpriteJob job;
-			job.TextureID = texture->ResourceID;
-			job.Texture = *texture;
+			ModelJob job;
+			job.TextureID = texGroup.Texture->ResourceID;
+			job.DiffuseTexture = *texGroup.Texture;
+			job.NormalTexture = (texGroup.NormalMap) ? *texGroup.NormalMap : 0;
+			job.SpecularTexture = (texGroup.SpecularMap) ? *texGroup.SpecularMap : 0;
+			job.VAO = model->VAO;
+			job.StartIndex = texGroup.StartIndex;
+			job.EndIndex = texGroup.EndIndex;
 			job.ModelMatrix = modelMatrix;
+					
+			RenderQueue.Add(job);
 		}
-	};
+	}
+
+	void EnqueueSprite(Texture* texture, glm::mat4 modelMatrix)
+	{
+		SpriteJob job;
+		job.TextureID = texture->ResourceID;
+		job.Texture = *texture;
+		job.ModelMatrix = modelMatrix;
+
+		RenderQueue.Add(job);
+	}
+};
 
 }
 

src/GameWorld.cpp

@@ -5,8 +5,8 @@ void GameWorld::Initialize()
 {
 	World::Initialize();
 
-	m_ResourceManager.Preload("Model", "Models/Placeholders/PhysicsTest/Plane.obj");
-	m_ResourceManager.Preload("Model", "Models/Placeholders/PhysicsTest/ArrowCube.obj");
+	ResourceManager->Preload("Model", "Models/Placeholders/PhysicsTest/Plane.obj");
+	ResourceManager->Preload("Model", "Models/Placeholders/PhysicsTest/ArrowCube.obj");
 
 	BindKey(GLFW_KEY_W, "vertical", 1.f);
 	BindKey(GLFW_KEY_S, "vertical", -1.f);
@@ -1183,18 +1183,18 @@ void GameWorld::RegisterComponents()
 
 void GameWorld::RegisterSystems()
 {
-	m_SystemFactory.Register<Systems::TransformSystem>([this]() { return new Systems::TransformSystem(this, m_EventBroker); });
+	m_SystemFactory.Register<Systems::TransformSystem>([this]() { return new Systems::TransformSystem(this, EventBroker, ResourceManager); });
 	//m_SystemFactory.Register<Systems::LevelGenerationSystem>([this]() { return new Systems::LevelGenerationSystem(this); });
-	m_SystemFactory.Register<Systems::InputSystem>([this]() { return new Systems::InputSystem(this, m_EventBroker); });
-	m_SystemFactory.Register<Systems::DebugSystem>([this]() { return new Systems::DebugSystem(this, m_EventBroker); });
+	m_SystemFactory.Register<Systems::InputSystem>([this]() { return new Systems::InputSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::DebugSystem>([this]() { return new Systems::DebugSystem(this, EventBroker, ResourceManager); });
 	//m_SystemFactory.Register<Systems::CollisionSystem>([this]() { return new Systems::CollisionSystem(this); });
-	m_SystemFactory.Register<Systems::ParticleSystem>([this]() { return new Systems::ParticleSystem(this, m_EventBroker); });
+	m_SystemFactory.Register<Systems::ParticleSystem>([this]() { return new Systems::ParticleSystem(this, EventBroker, ResourceManager); });
 	//m_SystemFactory.Register<Systems::PlayerSystem>([this]() { return new Systems::PlayerSystem(this); });
-	m_SystemFactory.Register<Systems::FreeSteeringSystem>([this]() { return new Systems::FreeSteeringSystem(this, m_EventBroker); });
-	m_SystemFactory.Register<Systems::TankSteeringSystem>([this]() { return new Systems::TankSteeringSystem(this, m_EventBroker); });
-	m_SystemFactory.Register<Systems::SoundSystem>([this]() { return new Systems::SoundSystem(this, m_EventBroker); });
-	m_SystemFactory.Register<Systems::PhysicsSystem>([this]() { return new Systems::PhysicsSystem(this, m_EventBroker); });
-	m_SystemFactory.Register<Systems::RenderSystem>([this]() { return new Systems::RenderSystem(this, m_EventBroker, m_Renderer); });
+	m_SystemFactory.Register<Systems::FreeSteeringSystem>([this]() { return new Systems::FreeSteeringSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::TankSteeringSystem>([this]() { return new Systems::TankSteeringSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::SoundSystem>([this]() { return new Systems::SoundSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::PhysicsSystem>([this]() { return new Systems::PhysicsSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::RenderSystem>([this]() { return new Systems::RenderSystem(this, EventBroker, ResourceManager); });
 }
 
 void GameWorld::AddSystems()
@@ -1219,7 +1219,7 @@ void GameWorld::BindKey(int keyCode, std::string command, float value)
 	e.KeyCode = keyCode;
 	e.Command = command;
 	e.Value = value;
-	m_EventBroker->Publish(e);
+	EventBroker->Publish(e);
 }
 
 void GameWorld::BindMouseButton(int button, std::string command, float value)
@@ -1228,7 +1228,7 @@ void GameWorld::BindMouseButton(int button, std::string command, float value)
 	e.Button = button;
 	e.Command = command;
 	e.Value = value;
-	m_EventBroker->Publish(e);
+	EventBroker->Publish(e);
 }
 
 void GameWorld::BindGamepadAxis(Gamepad::Axis axis, std::string command, float value)
@@ -1237,7 +1237,7 @@ void GameWorld::BindGamepadAxis(Gamepad::Axis axis, std::string command, float v
 	e.Axis = axis;
 	e.Command = command;
 	e.Value = value;
-	m_EventBroker->Publish(e);
+	EventBroker->Publish(e);
 }
 
 void GameWorld::BindGamepadButton(Gamepad::Button button, std::string command, float value)
@@ -1246,5 +1246,5 @@ void GameWorld::BindGamepadButton(Gamepad::Button button, std::string command, f
 	e.Button = button;
 	e.Command = command;
 	e.Value = value;
-	m_EventBroker->Publish(e);
+	EventBroker->Publish(e);
 }

src/GameWorld.h

@@ -45,8 +45,9 @@
 class GameWorld : public World
 {
 public:
-	GameWorld(std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<Renderer> renderer)
-		: World(eventBroker), m_Renderer(renderer) { }
+	GameWorld(std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: World(eventBroker, resourceManager)
+	{ }
 
 	void Initialize();
 
@@ -57,8 +58,6 @@ public:
 	void Update(double dt);
 
 private:
-	std::shared_ptr<Renderer> m_Renderer;
-
 	void BindKey(int keyCode, std::string command, float value);
 	void BindMouseButton(int button, std::string command, float value);
 	void BindGamepadAxis(Gamepad::Axis axis, std::string command, float value);

src/Model.cpp

@@ -1,7 +1,7 @@
 #include "PrecompiledHeader.h"
 #include "Model.h"
 
-Model::Model(ResourceManager* rm, OBJ &obj)
+Model::Model(std::shared_ptr<ResourceManager> rm, OBJ &obj)
 {
 	OBJ::MaterialInfo* currentMaterial = nullptr;
 	TextureGroup* currentTexGroup = nullptr;

src/Model.h

@@ -17,7 +17,7 @@
 class Model : public Resource
 {
 public:
-	Model(ResourceManager* rm, OBJ &obj);
+	Model(std::shared_ptr<ResourceManager> resourceManager, OBJ &obj);
 
 	struct TextureGroup
 	{

src/RenderQueue.h

@@ -12,17 +12,12 @@ class RenderQueue;
 
 struct RenderJob
 {
-	template <typename JobType>
-	friend class RenderQueue<JobType>;
+	friend class RenderQueue;
 
 protected:
 	uint64_t Hash;
 
 	virtual void CalculateHash() = 0;
-	{
-		Hash = ViewportID << 58 // 6 bits 
-			 | TextureID << 42; // 16 bits
-	}
 
 	bool operator<(const RenderJob& rhs)
 	{
@@ -59,14 +54,14 @@ struct SpriteJob : RenderJob
 	}
 };
 
-template <typename JobType>
 class RenderQueue
 {
 public:
-	void Add(JobType &job)
+	template <typename T>
+	void Add(T &job)
 	{
 		job.CalculateHash();
-		m_Jobs.push_front(job);
+		m_Jobs.push_front(std::shared_ptr<T>(new T(job)));
 		m_Jobs.sort();
 	}
 
@@ -76,7 +71,7 @@ public:
 	}
 
 private:
-	std::forward_list<JobType> m_Jobs;
+	std::forward_list<std::shared_ptr<RenderJob>> m_Jobs;
 };
 
 #endif // RenderQueue_h__

src/Renderer.cpp

@@ -66,8 +66,8 @@ void Renderer::Initialize()
 	}
 
 	// Create Camera
-	m_Camera = std::make_shared<Camera>(45.f, (float)m_Width / m_Height, 0.01f, 1000.f);
-	m_Camera->Position(glm::vec3(0.0f, 0.0f, 2.f));
+	m_Camera = std::make_shared<Camera>(45.f, 0.01f, 1000.f);
+	m_Camera->SetPosition(glm::vec3(0.0f, 0.0f, 2.f));
 
 	glfwSwapInterval(m_VSync);
 	glEnable(GL_CULL_FACE);
@@ -211,6 +211,11 @@ void Renderer::Draw(double dt)
 	glfwSwapBuffers(m_Window);
 }
 
+void Renderer::Draw(RenderQueue &rq)
+{
+
+}
+
 #pragma region TempRegion
 
 void Renderer::DrawSkybox()
@@ -220,7 +225,7 @@ void Renderer::DrawSkybox()
 
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	m_ShaderProgramSkybox.Bind();
-	glm::mat4 cameraMatrix = m_Camera->ProjectionMatrix() * glm::toMat4(glm::inverse(m_Camera->Orientation()));
+	glm::mat4 cameraMatrix = m_Camera->ProjectionMatrix((float)m_Width / m_Height) * glm::toMat4(glm::inverse(m_Camera->Orientation()));
 	glUniformMatrix4fv(glGetUniformLocation(m_ShaderProgramSkybox.GetHandle(), "MVP"), 1, GL_FALSE, glm::value_ptr(cameraMatrix));
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	m_Skybox->Draw();
@@ -719,7 +724,7 @@ void Renderer::DrawFBOScene(Viewport &viewport)
 // 	glCullFace(GL_BACK);	//Make it so that only the back faces are rendered
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //Draws filled polygons
 
-	glm::mat4 cameraMatrix = viewport.Camera->ProjectionMatrix() * viewport.Camera->ViewMatrix();
+	glm::mat4 cameraMatrix = viewport.Camera->ProjectionMatrix((float)m_Width / m_Height) * viewport.Camera->ViewMatrix();
 	glm::mat4 MVP;
 	glm::mat4 biasMatrix(
 		0.5, 0.0, 0.0, 0.0,
@@ -751,7 +756,7 @@ void Renderer::DrawFBOScene(Viewport &viewport)
 		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "DepthMVP"), 1, GL_FALSE, glm::value_ptr(depthMVP));
 		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
 		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "V"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ViewMatrix()));
-		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ProjectionMatrix()));
+		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ProjectionMatrix((float)m_Width / m_Height)));
 		glBindVertexArray(model->VAO);
 		for (auto texGroup : model->TextureGroups)
 		{
@@ -781,7 +786,7 @@ void Renderer::DrawFBOScene(Viewport &viewport)
 		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "DepthMVP"), 1, GL_FALSE, glm::value_ptr(depthMVP));
 		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
 		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "V"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ViewMatrix()));
-		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ProjectionMatrix()));
+		glUniformMatrix4fv(glGetUniformLocation(m_FirstPassProgram.GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ProjectionMatrix((float)m_Width / m_Height)));
 		
 		glActiveTexture(GL_TEXTURE0);
 		glBindTexture(GL_TEXTURE_2D, *texture);
@@ -802,7 +807,7 @@ void Renderer::DrawLightScene(Viewport &viewport)
 	glDepthMask (GL_FALSE);
 	glBindVertexArray(m_sphereModel->VAO);
 
-	glm::mat4 cameraMatrix = viewport.Camera->ProjectionMatrix() * viewport.Camera->ViewMatrix();
+	glm::mat4 cameraMatrix = viewport.Camera->ProjectionMatrix((float)m_Width / m_Height) * viewport.Camera->ViewMatrix();
 	glm::mat4 MVP;
 
 	for (auto &light : Lights)
@@ -812,7 +817,7 @@ void Renderer::DrawLightScene(Viewport &viewport)
 		glUniform2fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "ViewportSize"), 1,glm::value_ptr(glm::vec2(m_Width, m_Height)));
 		glUniformMatrix4fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
 		glUniformMatrix4fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "V"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ViewMatrix()));
-		glUniformMatrix4fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ProjectionMatrix()));
+		glUniformMatrix4fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(viewport.Camera->ProjectionMatrix((float)m_Width / m_Height)));
 		glUniformMatrix4fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "M"), 1, GL_FALSE, glm::value_ptr(light.SphereModelMatrix));
 		glUniform3fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "ls"), 1, glm::value_ptr(light.Specular));
 		glUniform3fv(glGetUniformLocation(m_SecondPassProgram.GetHandle(), "ld"), 1, glm::value_ptr(light.Diffuse));
@@ -868,7 +873,7 @@ void Renderer::UpdateSunProjection()
 		glm::vec3(1.f, 1.f, 1.f)
 	};
 
-	glm::mat4 inverseProjectionViewMatrix =  glm::inverse(m_Camera->ViewMatrix()) * glm::inverse(m_Camera->ProjectionMatrix());
+	glm::mat4 inverseProjectionViewMatrix = glm::inverse(m_Camera->ViewMatrix()) * glm::inverse(m_Camera->ProjectionMatrix((float)m_Width / m_Height));
 	//Also * with world matrix for light
 
 	for(auto corner : NDCCube)
@@ -883,33 +888,33 @@ void Renderer::UpdateSunProjection()
 
 void Renderer::RegisterViewport(int identifier, float left, float top, float right, float bottom)
 {
-	Viewport v;
+	/*Viewport v;
 	v.Left = left;
 	v.Top = top;
 	v.Right = right;
 	v.Bottom = bottom;
 	v.Camera = nullptr;
-	m_Viewports[identifier] = v;
+	m_Viewports[identifier] = v;*/
 }
 
 void Renderer::RegisterCamera(int identifier, float FOV, float nearClip, float farClip)
 {
-	m_Cameras[identifier] = std::make_shared<Camera>(FOV, (float)m_Width / m_Height, nearClip, farClip);
+	m_Cameras[identifier] = std::make_shared<Camera>(FOV, nearClip, farClip);
 }
 
 void Renderer::UpdateViewport(int viewportIdentifier, int cameraIdentifier)
 {
-	auto &viewport = m_Viewports[viewportIdentifier];
-	auto camera = m_Cameras[cameraIdentifier];
-	camera->AspectRatio(((viewport.Right - viewport.Left) * m_Width) / ((viewport.Bottom - viewport.Top) * m_Height));
-	viewport.Camera = camera;
+	//auto &viewport = m_Viewports[viewportIdentifier];
+	//auto camera = m_Cameras[cameraIdentifier];
+	//camera->AspectRatio(((viewport.Right - viewport.Left) * m_Width) / ((viewport.Bottom - viewport.Top) * m_Height));
+	//viewport.Camera = camera;
 }
 
 void Renderer::UpdateCamera(int cameraIdentifier, glm::vec3 position, glm::quat orientation, float FOV, float nearClip, float farClip)
 {
-	m_Cameras[cameraIdentifier]->Position(position);
+	/*m_Cameras[cameraIdentifier]->Position(position);
 	m_Cameras[cameraIdentifier]->Orientation(orientation);
 	m_Cameras[cameraIdentifier]->FOV(FOV);
 	m_Cameras[cameraIdentifier]->NearClip(nearClip);
-	m_Cameras[cameraIdentifier]->FarClip(farClip);
+	m_Cameras[cameraIdentifier]->FarClip(farClip);*/
 }

src/Renderer.h

@@ -13,6 +13,8 @@
 #include "Components/PointLight.h"
 #include "Skybox.h"
 #include "ResourceManager.h"
+#include "Util/Rectangle.h"
+#include "RenderQueue.h"
 
 class Renderer
 {
@@ -40,6 +42,21 @@ public:
 	void UpdateViewport(int viewportIdentifier, int cameraIdentifier);
 	void UpdateCamera(int cameraIdentifier, glm::vec3 position, glm::quat orientation, float FOV, float nearClip, float farClip);
 
+#pragma region NEWSTUFF
+	void SetViewport(const Rectangle &viewport)
+	{
+		m_Viewport = viewport;
+	}
+
+	void SetCamera(std::shared_ptr<Camera> camera)
+	{
+		m_Camera = camera;
+	}
+
+	void Draw(RenderQueue &rq);
+
+#pragma endregion
+
 	void AddModelToDraw(Model* model, glm::vec3 position, glm::quat orientation, glm::vec3 scale, bool visible, bool shadowCaster);
 	void AddTextureToDraw(Texture* texture, glm::vec3 position, glm::quat orientation, glm::vec3 scale);
 	void AddTextToDraw();
@@ -84,6 +101,9 @@ private:
 	std::unordered_map<int, Viewport> m_Viewports;
 	std::unordered_map<int, std::shared_ptr<Camera>> m_Cameras;
 
+	Rectangle m_Viewport;
+	std::shared_ptr<Camera> m_Camera;
+
 	struct Light
 	{
 		glm::vec3 Position;
@@ -135,8 +155,6 @@ private:
 
 	bool m_QuadView;
 
-	std::shared_ptr<Camera> m_Camera;
-
 	ShaderProgram m_ShaderProgram;
 	ShaderProgram m_FirstPassProgram;
 	ShaderProgram m_SecondPassProgram;

src/System.h

@@ -12,13 +12,15 @@ class World;
 class System
 {
 public:
-	System(World* world, std::shared_ptr<EventBroker> eventBroker) 
+	System(World* world, std::shared_ptr<EventBroker> eventBroker, std::shared_ptr<ResourceManager> resourceManager)
 		: m_World(world)
-		, EventBroker(eventBroker) { }
+		, EventBroker(eventBroker)
+		, ResourceManager(resourceManager)
+	{ }
 	virtual ~System() { }
 
 	virtual void RegisterComponents(ComponentFactory* cf) { }
-	virtual void RegisterResourceTypes(ResourceManager* rm) { }
+	virtual void RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm) { }
 
 	virtual void Initialize() { }
 
@@ -37,6 +39,7 @@ public:
 protected:
 	World* m_World;
 	std::shared_ptr<EventBroker> EventBroker;
+	std::shared_ptr<ResourceManager> ResourceManager;
 };
 
 class SystemFactory : public Factory<System*> { };

src/Systems/DebugSystem.h

@@ -12,8 +12,9 @@ namespace Systems
 class DebugSystem : public System
 {
 public:
-	DebugSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	DebugSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 
 	void Initialize() override;
 

src/Systems/FreeSteeringSystem.h

@@ -12,8 +12,9 @@ namespace Systems
 class FreeSteeringSystem : public System
 {
 public:
-	FreeSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	FreeSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 
 	void RegisterComponents(ComponentFactory* cf) override;
 	void Initialize() override;

src/Systems/HelicopterSteeringSystem.h

@@ -11,8 +11,9 @@ namespace Systems
 class HelicopterSteeringSystem : public System
 {
 public:
-	HelicopterSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	HelicopterSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 
 	void RegisterComponents(ComponentFactory* cf) override;
 	void Initialize() override;

src/Systems/InputSystem.h

@@ -25,8 +25,9 @@ namespace Systems
 class InputSystem : public System
 {
 public:
-	InputSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	InputSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 
 	void RegisterComponents(ComponentFactory* cf) override;
 	void Initialize() override;

src/Systems/ParticleSystem.h

@@ -26,8 +26,9 @@ namespace Systems
 class ParticleSystem : public System
 {
 public:
-	ParticleSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	ParticleSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 
 	void RegisterComponents(ComponentFactory* cf) override;
 	void Update(double dt) override;

src/Systems/PhysicsSystem.cpp

@@ -437,7 +437,7 @@ void Systems::PhysicsSystem::OnEntityCommit( EntityID entity )
 		{
 			std::vector<hkReal>* vertices = new std::vector<hkReal>;
 			std::vector<hkUint16>* vertexIndices = new std::vector<hkUint16>;
-			auto meshShape = m_World->GetResourceManager()->Load<OBJ>("OBJ", meshShapeComponent->ResourceName);
+			auto meshShape = ResourceManager->Load<OBJ>("OBJ", meshShapeComponent->ResourceName);
 
 			for (auto &vertex : meshShape->Vertices)
 			{

src/Systems/PhysicsSystem.h

@@ -96,8 +96,9 @@ namespace Systems
 class PhysicsSystem : public System
 {
 public:
-	PhysicsSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	PhysicsSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager) 
+	{ }
 
 	void RegisterComponents(ComponentFactory* cf) override;
 	void Initialize() override;

src/Systems/RenderSystem.cpp

@@ -2,7 +2,7 @@
 #include "RenderSystem.h"
 #include "World.h"
 
-void Systems::RenderSystem::RegisterResourceTypes(ResourceManager* rm)
+void Systems::RenderSystem::RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm)
 {
 	rm->RegisterType("Model", [rm](std::string resourceName) { return new Model(rm, *rm->Load<OBJ>("OBJ", resourceName)); });
 	rm->RegisterType("OBJ", [](std::string resourceName) { return new OBJ(resourceName); });
@@ -21,100 +21,99 @@ void Systems::RenderSystem::RegisterComponents(ComponentFactory* cf)
 
 void Systems::RenderSystem::OnEntityCommit(EntityID entity)
 {
-	auto transform = m_World->GetComponent<Components::Transform>(entity);
+	//auto transform = m_World->GetComponent<Components::Transform>(entity);
 
-	auto camera = m_World->GetComponent<Components::Camera>(entity);
-	if (transform && camera)
-	{
-		m_Renderer->RegisterCamera(entity, camera->FOV, camera->NearClip, camera->FarClip);
-		m_Renderer->UpdateCamera(entity, m_TransformSystem->AbsolutePosition(entity), m_TransformSystem->AbsoluteOrientation(entity), camera->FOV, camera->NearClip, camera->FarClip);
-	}
+	//auto camera = m_World->GetComponent<Components::Camera>(entity);
+	//if (transform && camera)
+	//{
+	//	m_Renderer->RegisterCamera(entity, camera->FOV, camera->NearClip, camera->FarClip);
+	//	m_Renderer->UpdateCamera(entity, m_TransformSystem->AbsolutePosition(entity), m_TransformSystem->AbsoluteOrientation(entity), camera->FOV, camera->NearClip, camera->FarClip);
+	//}
 
-	auto viewport = m_World->GetComponent<Components::Viewport>(entity);
-	if (viewport)
-	{
-		m_Renderer->RegisterViewport(entity, viewport->Left, viewport->Top, viewport->Right, viewport->Bottom);
-		if (viewport->Camera != 0)
-		{
-			m_Renderer->UpdateViewport(entity, viewport->Camera);
-		}
-	}
+	//auto viewport = m_World->GetComponent<Components::Viewport>(entity);
+	//if (viewport)
+	//{
+	//	m_Renderer->RegisterViewport(entity, viewport->Left, viewport->Top, viewport->Right, viewport->Bottom);
+	//	if (viewport->Camera != 0)
+	//	{
+	//		m_Renderer->UpdateViewport(entity, viewport->Camera);
+	//	}
+	//}
 }
 
 void Systems::RenderSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
-	auto templateComponent = m_World->GetComponent<Components::Template>(entity);
-	if (templateComponent)
-		return;
+	//auto templateComponent = m_World->GetComponent<Components::Template>(entity);
+	//if (templateComponent)
+	//	return;
 
-	auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+	//auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
 
-	// Draw models
-	auto modelComponent = m_World->GetComponent<Components::Model>(entity);
-	if (transformComponent && modelComponent)
-	{
-		auto model = m_World->GetResourceManager()->Load<Model>("Model", modelComponent->ModelFile);
-		if (model)
-		{
-			/*glm::vec3 position = m_TransformSystem->AbsolutePosition(entity);
-			glm::quat orientation = m_TransformSystem->AbsoluteOrientation(entity);
-			glm::vec3 scale = m_TransformSystem->AbsoluteScale(entity);*/
-			Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-			m_Renderer->AddModelToDraw(model, absoluteTransform.Position, absoluteTransform.Orientation, absoluteTransform.Scale, modelComponent->Visible, modelComponent->ShadowCaster);
-		}
-	}
+	//// Draw models
+	//auto modelComponent = m_World->GetComponent<Components::Model>(entity);
+	//if (transformComponent && modelComponent)
+	//{
+	//	auto model = m_World->ResourceManager->Load<Model>("Model", modelComponent->ModelFile);
+	//	if (model)
+	//	{
+	//		/*glm::vec3 position = m_TransformSystem->AbsolutePosition(entity);
+	//		glm::quat orientation = m_TransformSystem->AbsoluteOrientation(entity);
+	//		glm::vec3 scale = m_TransformSystem->AbsoluteScale(entity);*/
+	//		Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
+	//		m_Renderer->AddModelToDraw(model, absoluteTransform.Position, absoluteTransform.Orientation, absoluteTransform.Scale, modelComponent->Visible, modelComponent->ShadowCaster);
+	//	}
+	//}
 
-	auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity);
-	if (transformComponent && pointLightComponent)
-	{
-		glm::vec3 position = m_TransformSystem->AbsolutePosition(entity);
-		m_Renderer->AddPointLightToDraw(
-			position,
-			pointLightComponent->Specular,
-			pointLightComponent->Diffuse,
-			pointLightComponent->specularExponent,
-			pointLightComponent->ConstantAttenuation,
-			pointLightComponent->LinearAttenuation,
-			pointLightComponent->QuadraticAttenuation
-			);
-	}
+	//auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity);
+	//if (transformComponent && pointLightComponent)
+	//{
+	//	glm::vec3 position = m_TransformSystem->AbsolutePosition(entity);
+	//	m_Renderer->AddPointLightToDraw(
+	//		position,
+	//		pointLightComponent->Specular,
+	//		pointLightComponent->Diffuse,
+	//		pointLightComponent->specularExponent,
+	//		pointLightComponent->ConstantAttenuation,
+	//		pointLightComponent->LinearAttenuation,
+	//		pointLightComponent->QuadraticAttenuation
+	//		);
+	//}
 
-	auto cameraComponent = m_World->GetComponent<Components::Camera>(entity);
-	if (transformComponent && cameraComponent)
-	{
-		m_Renderer->UpdateCamera(entity
-			, m_TransformSystem->AbsolutePosition(entity)
-			, m_TransformSystem->AbsoluteOrientation(entity)
-			, cameraComponent->FOV
-			, cameraComponent->NearClip
-			, cameraComponent->FarClip);
-	}
+	//auto cameraComponent = m_World->GetComponent<Components::Camera>(entity);
+	//if (transformComponent && cameraComponent)
+	//{
+	//	m_Renderer->UpdateCamera(entity
+	//		, m_TransformSystem->AbsolutePosition(entity)
+	//		, m_TransformSystem->AbsoluteOrientation(entity)
+	//		, cameraComponent->FOV
+	//		, cameraComponent->NearClip
+	//		, cameraComponent->FarClip);
+	//}
 
-	auto viewportComponent = m_World->GetComponent<Components::Viewport>(entity);
-	if (viewportComponent)
-	{
-		if (viewportComponent->Camera != 0)
-		{
-			m_Renderer->UpdateViewport(entity, viewportComponent->Camera);
-		}
-	}
+	//auto viewportComponent = m_World->GetComponent<Components::Viewport>(entity);
+	//if (viewportComponent)
+	//{
+	//	if (viewportComponent->Camera != 0)
+	//	{
+	//		m_Renderer->UpdateViewport(entity, viewportComponent->Camera);
+	//	}
+	//}
 
-	auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
-	if (transformComponent && spriteComponent)
-	{
-		//TEMP
-		Texture* texture = m_World->GetResourceManager()->Load<Texture>("Texture", spriteComponent->SpriteFile);
-		//glBindTexture(GL_TEXTURE_2D, texture);
-		auto transform = m_World->GetComponent<Components::Transform>(spriteComponent->Entity);
-		glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(transform->Orientation).z, glm::vec3(0, 0, -1));
-		m_Renderer->AddTextureToDraw(texture, transform->Position, orientation2D, transform->Scale);
-	}
+	//auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
+	//if (transformComponent && spriteComponent)
+	//{
+	//	//TEMP
+	//	Texture* texture = m_World->ResourceManager->Load<Texture>("Texture", spriteComponent->SpriteFile);
+	//	//glBindTexture(GL_TEXTURE_2D, texture);
+	//	auto transform = m_World->GetComponent<Components::Transform>(spriteComponent->Entity);
+	//	glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(transform->Orientation).z, glm::vec3(0, 0, -1));
+	//	m_Renderer->AddTextureToDraw(texture, transform->Position, orientation2D, transform->Scale);
+	//}
 }
 
 void Systems::RenderSystem::Initialize()
 {
-	m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
-
-	m_Renderer->SetSphereModel(m_World->GetResourceManager()->Load<Model>("Model", "Models/Placeholders/PhysicsTest/Sphere.obj"));
-}
+	//m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
 
+	//m_Renderer->SetSphereModel(m_World->ResourceManager->Load<Model>("Model", "Models/Placeholders/PhysicsTest/Sphere.obj"));
+}

src/Systems/RenderSystem.h

@@ -18,6 +18,7 @@
 #include "Components/Template.h"
 #include "Components/Transform.h"
 #include "Renderer.h"
+#include "RenderQueue.h"
 
 namespace Systems
 {
@@ -25,12 +26,12 @@ namespace Systems
 class  RenderSystem : public System
 {
 public:
-	RenderSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<Renderer> renderer)
-		: System(world, eventBroker)
-		, m_Renderer(renderer) { }
+	RenderSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 
 	void RegisterComponents(ComponentFactory* cf) override;
-	void RegisterResourceTypes(ResourceManager* rm) override;
+	void RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm) override;
 	void Initialize() override;
 
 	std::unordered_map<std::string, std::shared_ptr<Model>> m_CachedModels;
@@ -38,12 +39,12 @@ public:
 	void OnEntityCommit(EntityID entity) override;
 	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
-
-
-
 private:
-	std::shared_ptr<Renderer> m_Renderer;
 	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
+
+	void EnqueueModel(Model* model, glm::mat4 modelMatrix);
+	void EnqueueSprite(Texture* texture, glm::mat4 modelMatrix);
+
 };
 
 

src/Systems/SoundSystem.cpp

@@ -32,7 +32,7 @@ void Systems::SoundSystem::RegisterComponents(ComponentFactory* cf)
 	cf->Register<Components::SoundEmitter>([]() { return new Components::SoundEmitter(); });
 }
 
-void Systems::SoundSystem::RegisterResourceTypes(ResourceManager* rm)
+void Systems::SoundSystem::RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm)
 {
 	rm->RegisterType("Sound", [](std::string resourceName) { return new Sound(resourceName); });
 }
@@ -94,7 +94,7 @@ void Systems::SoundSystem::PlaySound(Components::SoundEmitter* emitter, std::str
 	if (m_Sources.find(emitter) == m_Sources.end())
 		return;
 
-	ALuint buffer = *m_World->GetResourceManager()->Load<Sound>("Sound", fileName);
+	ALuint buffer = *ResourceManager->Load<Sound>("Sound", fileName);
 	if (buffer == 0)
 		return;
 	ALuint source = m_Sources[emitter];
@@ -104,7 +104,7 @@ void Systems::SoundSystem::PlaySound(Components::SoundEmitter* emitter, std::str
 
 void Systems::SoundSystem::PlaySound(std::shared_ptr<Components::SoundEmitter> emitter)
 {
-	ALuint buffer = *m_World->GetResourceManager()->Load<Sound>("Sound", emitter->Path);
+	ALuint buffer = *ResourceManager->Load<Sound>("Sound", emitter->Path);
 	ALuint source = m_Sources[emitter.get()];
 	alSourcei(source, AL_BUFFER, buffer);
 	alSourcePlay(m_Sources[emitter.get()]);
@@ -151,7 +151,7 @@ bool Systems::SoundSystem::OnPlaySound(const Events::PlaySound &event)
 {
 	LOG_DEBUG("Events::PlaySound.Resource = %s", event.Resource.c_str());
 
-	ALuint buffer = *m_World->GetResourceManager()->Load<Sound>("Sound", event.Resource);
+	ALuint buffer = *ResourceManager->Load<Sound>("Sound", event.Resource);
 	ALuint source = m_Sources.begin()->second;
 	alSourcei(source, AL_BUFFER, buffer);
 	alSourcePlay(source);

src/Systems/SoundSystem.h

@@ -16,11 +16,12 @@ namespace Systems
 class SoundSystem : public System
 {
 public:
-	SoundSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	SoundSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 
 	void RegisterComponents(ComponentFactory* cf) override;
-	void RegisterResourceTypes(ResourceManager* rm) override;
+	void RegisterResourceTypes(std::shared_ptr<::ResourceManager> rm) override;
 	void Initialize() override;
 
 	void Update(double dt) override;

src/Systems/TankSteeringSystem.h

@@ -21,8 +21,9 @@ namespace Systems
 	class TankSteeringSystem : public System
 	{
 	public:
-		TankSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-			: System(world, eventBroker) { }
+		TankSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+			: System(world, eventBroker, resourceManager)
+		{ }
 
 		void RegisterComponents(ComponentFactory* cf) override;
 		void Initialize() override;

src/Systems/TransformSystem.h

@@ -10,8 +10,9 @@ namespace Systems
 class TransformSystem : public System
 {
 public:
-	TransformSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
-		: System(world, eventBroker) { }
+	TransformSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: System(world, eventBroker, resourceManager)
+	{ }
 	//void Update(double dt) override;
 	//void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 	

src/Util/Rectangle.h

@@ -19,24 +19,24 @@ struct Rectangle
 	int Width;
 	int Height;
 
-	const int& GetLeft() const { return X; }
+	virtual int Left() const { return X; }
 	void SetLeft(int left) 
 	{
 		Width += X - left;
 		X = left;
 	}
-	int GetRight() const { return X + Width; }
+	virtual int Right() const { return X + Width; }
 	void SetRight(int right) 
 	{
 		Width = right - X;
 	}
-	const int& GetTop() const { return Y; }
+	virtual int Top() const { return Y; }
 	void SetTop(int top) 
 	{ 
 		Height += Y - top;
 		Y = top;
 	}
-	int GetBottom() const { return Y + Height; }
+	virtual int Bottom() const { return Y + Height; }
 	int SetBottom(int bottom)
 	{ 
 		Height = bottom - Y;
@@ -44,15 +44,15 @@ struct Rectangle
 
 	Rectangle& operator+=(const Rectangle &rhs)
 	{
-		SetLeft(std::min(GetLeft(), rhs.GetLeft()));
-		SetRight(std::max(GetRight(), rhs.GetRight()));
-		SetTop(std::min(GetTop(), rhs.GetTop()));
-		SetBottom(std::max(GetBottom(), rhs.GetBottom()));
+		SetLeft(std::min(Left(), rhs.Left()));
+		SetRight(std::max(Right(), rhs.Right()));
+		SetTop(std::min(Top(), rhs.Top()));
+		SetBottom(std::max(Bottom(), rhs.Bottom()));
 	}
 
 	static bool Intersects(const Rectangle &r1, const Rectangle &r2)
 	{
-		return !(r2.GetLeft() > r1.GetRight() || r2.GetRight() < r1.GetLeft() || r2.GetTop() > r1.GetBottom() || r2.GetBottom() < r1.GetTop());
+		return !(r2.Left() > r1.Right() || r2.Right() < r1.Left() || r2.Top() > r1.Bottom() || r2.Bottom() < r1.Top());
 	}
 };
 

src/World.cpp

@@ -38,7 +38,7 @@ void World::Update(double dt)
 	{
 		const std::string &type = pair.first;
 		auto system = pair.second;
-		m_EventBroker->Process(type);
+		EventBroker->Process(type);
 		system->Update(dt);
 		RecursiveUpdate(system, dt, 0);
 	}
@@ -129,7 +129,7 @@ void World::Initialize()
 	{
 		auto system = pair.second;
 		system->RegisterComponents(&m_ComponentFactory);
-		system->RegisterResourceTypes(&m_ResourceManager);
+		system->RegisterResourceTypes(ResourceManager);
 		system->Initialize();
 	}
 }

src/World.h

@@ -21,8 +21,9 @@
 class World
 {
 public:
-	World(std::shared_ptr<::EventBroker> eventBroker)
-		: m_EventBroker(eventBroker)
+	World(std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
+		: EventBroker(eventBroker)
+		, ResourceManager(resourceManager)
 		, m_LastEntityID(0) { }
 	~World() { }
 
@@ -88,11 +89,10 @@ public:
 
 	std::unordered_map<EntityID, EntityID>* GetEntities() { return &m_EntityParents; }
 
-	//ResourceManager* GetResourceManager() { return &m_ResourceManager; }
-	std::shared_ptr<::EventBroker> EventBroker() { return m_EventBroker; }
-
 protected:
-	std::shared_ptr<::EventBroker> m_EventBroker;
+	std::shared_ptr<::EventBroker> EventBroker;
+	std::shared_ptr<::ResourceManager> ResourceManager;
+
 	SystemFactory m_SystemFactory;
 	ComponentFactory m_ComponentFactory;
 

src/main.cpp

@@ -4,6 +4,7 @@
 int main(int argc, char* argv[])
 {
 	Engine engine(argc, argv);
+	LOG_INFO("------------ Engine initialized ------------");
 	while (engine.Running())
 		engine.Tick();