Initial work for pre-caching resources in render system

src/GameWorld.cpp

@@ -5,6 +5,12 @@ void GameWorld::Initialize()
 {
 	World::Initialize();
 
+	m_ResourceManager.RegisterResource("Model", "Models/Placeholders/PhysicsTest/Plane.obj");
+	m_ResourceManager.RegisterResource("Model", "Models/Placeholders/PhysicsTest/ArrowCube.obj");
+	m_ResourceManager.PreCache();
+
+	RegisterComponents();
+
 	{
 		auto camera = CreateEntity();
 		auto transform = AddComponent<Components::Transform>(camera, "Transform");
@@ -113,14 +119,9 @@ void GameWorld::Update(double dt)
 
 void GameWorld::RegisterComponents()
 {
-	m_ComponentFactory.Register("Camera", []() { return new Components::Camera(); });
-	m_ComponentFactory.Register("DirectionalLight", []() { return new Components::DirectionalLight(); });
 	m_ComponentFactory.Register("Input", []() { return new Components::Input(); });
-	m_ComponentFactory.Register("Model", []() { return new Components::Model(); });
 	m_ComponentFactory.Register("ParticleEmitter", []() { return new Components::ParticleEmitter(); });
-	m_ComponentFactory.Register("PointLight", []() { return new Components::PointLight(); });
 	m_ComponentFactory.Register("SoundEmitter", []() { return new Components::SoundEmitter(); });
-	m_ComponentFactory.Register("Sprite", []() { return new Components::Sprite(); });
 	m_ComponentFactory.Register("Template", []() { return new Components::Template(); });
 	m_ComponentFactory.Register("Transform", []() { return new Components::Transform(); });
 	m_ComponentFactory.Register("FreeSteering", []() { return new Components::FreeSteering(); });

src/Model.h

@@ -10,10 +10,11 @@
 #include <cstdlib>
 #include <stack>
 
+#include "ResourceManager.h"
 #include "Texture.h"
 #include "OBJ.h"
 
-class Model
+class Model : public Resource
 {
 public:
 	Model(OBJ &obj);

src/Renderer.cpp

@@ -369,11 +369,11 @@ void Renderer::AddTextToDraw()
 	//Add to draw shit vector
 }
 
-void Renderer::AddModelToDraw(std::shared_ptr<Model> model, glm::vec3 position, glm::quat orientation, glm::vec3 scale, bool visible, bool shadowCaster)
+void Renderer::AddModelToDraw(Model* model, glm::vec3 position, glm::quat orientation, glm::vec3 scale, bool visible, bool shadowCaster)
 {
 	glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
 	// You can now use ModelMatrix to build the MVP matrix
-	ModelsToRender.push_back(std::make_tuple(model.get(), modelMatrix, visible, shadowCaster));
+	ModelsToRender.push_back(std::make_tuple(model, modelMatrix, visible, shadowCaster));
 }
 
 void Renderer::AddPointLightToDraw(

src/Renderer.h

@@ -39,7 +39,7 @@ public:
 	void Draw(double dt);
 	void DrawText();
 
-	void AddModelToDraw(std::shared_ptr<Model> model, glm::vec3 position, glm::quat orientation, glm::vec3 scale, bool visible, bool shadowCaster);
+	void AddModelToDraw(Model* model, glm::vec3 position, glm::quat orientation, glm::vec3 scale, bool visible, bool shadowCaster);
 	void AddTextToDraw();
 	void AddPointLightToDraw(
 	    glm::vec3 _position,

src/ResourceManager.cpp

@@ -1,7 +1,7 @@
 #include "PrecompiledHeader.h"
-#include "ContentManager.h"
+#include "ResourceManager.h"
 
-Resource* ContentManager::CreateResource(std::string resourceType, std::string resourceName)
+Resource* ResourceManager::CreateResource(std::string resourceType, std::string resourceName)
 {
 	auto it = m_FactoryFunctions.find(resourceType);
 	if (it != m_FactoryFunctions.end())
@@ -14,7 +14,7 @@ Resource* ContentManager::CreateResource(std::string resourceType, std::string r
 	}
 }
 
-void ContentManager::PreCache()
+void ResourceManager::PreCache()
 {
 	LOG_INFO("Pre-caching resources...");
 	for (auto pair : m_RegisteredResources)
@@ -39,13 +39,13 @@ void ContentManager::PreCache()
 	}
 }
 
-void ContentManager::RegisterResource(std::string resourceType, std::string resourceName)
+void ResourceManager::RegisterResource(std::string resourceType, std::string resourceName)
 {
 	m_RegisteredResources[resourceName] = resourceType;
 	m_ResourceTypeIDs[resourceName] = m_ResourceTypeCount++;
 }
 
-void ContentManager::RegisterType(std::string resourceType, std::function<Resource*(std::string)> factoryFunction)
+void ResourceManager::RegisterType(std::string resourceType, std::function<Resource*(std::string)> factoryFunction)
 {
 	m_FactoryFunctions[resourceType] = factoryFunction;
 }

src/ResourceManager.h

@@ -1,5 +1,5 @@
-#ifndef ContentManager_h__
-#define ContentManager_h__
+#ifndef ResourceManager_h__
+#define ResourceManager_h__
 
 #include <string>
 #include <functional>
@@ -13,11 +13,6 @@ class Resource
 public:
 	unsigned int TypeID;
 	unsigned int ResourceID;
-	std::string ResourceName;
-
-protected:
-	Resource(std::string resourceName) 
-		: ResourceName(resourceName) {}
 };
 
 class ResourceManager
@@ -33,7 +28,7 @@ public:
 	void PreCache();
 
 	template <typename T>
-	T* Fetch(std::string resourceName);
+	T* Fetch(std::string resourceName) const;
 
 private:
 	unsigned int m_ResourceTypeCount = 0;
@@ -49,7 +44,7 @@ private:
 };
 
 template <typename T>
-T* ContentManager::Fetch(std::string resourceName)
+T* ResourceManager::Fetch(std::string resourceName) const
 {
 	if (m_ResourceCache.find(resourceName) == m_ResourceCache.end())
 	{
@@ -58,8 +53,8 @@ T* ContentManager::Fetch(std::string resourceName)
 	}
 	else
 	{
-		return static_cast<T*>(m_ResourceCache[resourceName]);
+		return static_cast<T*>(m_ResourceCache.at(resourceName));
 	}
 }
 
-#endif // ContentManager_h__
+#endif // ResourceManager_h__

src/System.h

@@ -4,6 +4,7 @@
 #include "Factory.h"
 #include "Entity.h"
 #include "Component.h"
+#include "ResourceManager.h"
 
 class World;
 
@@ -13,6 +14,9 @@ public:
 	System(World* world) : m_World(world) { }
 	virtual ~System() { }
 
+	virtual void RegisterComponents(ComponentFactory* cf) { } // TODO: Make abstract
+	virtual void RegisterResourceTypes(ResourceManager* rm) { } // TODO: Make abstract
+
 	virtual void Initialize() { }
 
 	// Called once per system every tick

src/Systems/RenderSystem.cpp

@@ -25,7 +25,7 @@ void Systems::RenderSystem::UpdateEntity(double dt, EntityID entity, EntityID pa
 			m_CachedModels[modelComponent->ModelFile] = std::make_shared<Model>(OBJ(modelComponent->ModelFile));
 		}
 
-		auto model = m_CachedModels[modelComponent->ModelFile];
+		auto model = m_World->GetResourceManager()->Fetch<Model>(modelComponent->ModelFile);
 		glm::vec3 position = m_TransformSystem->AbsolutePosition(entity);
 		glm::quat orientation = m_TransformSystem->AbsoluteOrientation(entity);
 		glm::vec3 scale = m_TransformSystem->AbsoluteScale(entity);
@@ -63,6 +63,21 @@ void Systems::RenderSystem::Initialize()
 	m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>("TransformSystem");
 }
 
+void Systems::RenderSystem::RegisterComponents(ComponentFactory* cf)
+{
+	cf->Register("Camera", []() { return new Components::Camera(); });
+	cf->Register("Model", []() { return new Components::Model(); });
+	cf->Register("Sprite", []() { return new Components::Sprite(); });
+	cf->Register("PointLight", []() { return new Components::PointLight(); });
+	cf->Register("DirectionalLight", []() { return new Components::DirectionalLight(); });
+}
+
+void Systems::RenderSystem::RegisterResourceTypes(ResourceManager* rm)
+{
+	rm->RegisterType("Texture", [](std::string resourceName) { return new Texture(resourceName); });
+	rm->RegisterType("Model", [](std::string resourceName) { return new Model(OBJ(resourceName)); });
+}
+
 
 
 

src/Systems/RenderSystem.h

@@ -7,9 +7,15 @@
 #include "Systems/TransformSystem.h"
 #include "Model.h"
 #include "Texture.h"
-#include "Components/Model.h"
 #include "Components/Transform.h"
 #include "Components/Camera.h"
+#include "Components/Model.h"
+#include "Components/Sprite.h"
+#include "Components/PointLight.h"
+#include "Components/DirectionalLight.h"
+
+#include "Components/Template.h"
+#include "Components/Transform.h"
 #include "Renderer.h"
 
 namespace Systems
@@ -21,6 +27,8 @@ public:
 	RenderSystem(World* world, std::shared_ptr<Renderer> renderer)
 		: System(world), m_Renderer(renderer) { }
 
+	void RegisterComponents(ComponentFactory* cf) override;
+	void RegisterResourceTypes(ResourceManager* rm) override;
 	void Initialize() override;
 
 	std::unordered_map<std::string, std::shared_ptr<Model>> m_CachedModels;
@@ -28,6 +36,9 @@ public:
 	void OnComponentCreated(std::string type, std::	shared_ptr<Component> component) override;
 	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
+
+
+
 private:
 	std::shared_ptr<Renderer> m_Renderer;
 	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;

src/Texture.cpp

@@ -2,7 +2,6 @@
 #include "Texture.h"
 
 Texture::Texture(std::string path)
-	: Resource(path)
 {
 	Load(path);
 }

src/Texture.h

@@ -6,7 +6,7 @@
 
 #include <SOIL.h>
 
-#include "ContentManager.h"
+#include "ResourceManager.h"
 
 class Texture : public Resource
 {

src/World.cpp

@@ -134,12 +134,13 @@ void World::Initialize()
 {
 	RegisterSystems();
 	AddSystems();
-	for (auto system : m_Systems)
+	for (auto pair : m_Systems)
 	{
-		system.second->Initialize();
+		auto system = pair.second;
+		system->RegisterComponents(&m_ComponentFactory);
+		system->RegisterResourceTypes(&m_ResourceManager);
+		system->Initialize();
 	}
-
-	RegisterComponents();
 }
 
 std::shared_ptr<Component> World::AddComponent(EntityID entity, std::string componentType)

src/World.h

@@ -10,12 +10,11 @@
 
 #include <boost/any.hpp>
 
-#include "Util/logging.h"
-
 #include "Factory.h"
 #include "Entity.h"
 #include "Component.h"
 #include "System.h"
+#include "ResourceManager.h"
 
 class World
 {
@@ -73,9 +72,12 @@ public:
 
 	std::unordered_map<EntityID, EntityID>* GetEntities() { return &m_EntityParents; }
 
+	const ResourceManager* GetResourceManager() const { return &m_ResourceManager; }
+
 protected:
 	SystemFactory m_SystemFactory;
 	ComponentFactory m_ComponentFactory;
+	ResourceManager m_ResourceManager;
 
 	std::unordered_map<std::string, std::shared_ptr<System>> m_Systems;