Adapted Escape the Dawn engine.

src/Systems/RenderSystem.cpp

@@ -0,0 +1,74 @@
+#include "PrecompiledHeader.h"
+#include "RenderSystem.h"
+#include "World.h"
+
+void Systems::RenderSystem::OnComponentCreated(std::string type, std::shared_ptr<Component> component)
+{
+	if(type == "Model")	{
+		auto modelComponent = std::static_pointer_cast<Components::Model>(component);
+	}
+}
+
+void Systems::RenderSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+	auto transformComponent = m_World->GetComponent<Components::Transform>(entity, "Transform");
+	if (transformComponent == nullptr)
+		return;
+
+	// Draw models
+	auto modelComponent = m_World->GetComponent<Components::Model>(entity, "Model");
+	if (modelComponent != nullptr) {
+		if (m_CachedModels.find(modelComponent->ModelFile) == m_CachedModels.end()){
+			m_CachedModels[modelComponent->ModelFile] = std::make_shared<Model>(OBJ(modelComponent->ModelFile));
+		}
+
+		auto model = m_CachedModels[modelComponent->ModelFile];
+		glm::vec3 position = m_TransformSystem->AbsolutePosition(entity);
+		glm::quat orientation = m_TransformSystem->AbsoluteOrientation(entity);
+		m_Renderer->AddModelToDraw(model, position, orientation, transformComponent->Scale, modelComponent->Visible, modelComponent->ShadowCaster);
+	}
+
+	// Debug draw bounds
+#ifdef DEBUG
+	auto collision = m_World->GetComponent<Components::Collision>(entity, "Collision");
+	auto bounds = m_World->GetComponent<Components::Bounds>(entity, "Bounds");
+	if (bounds != nullptr) {
+		glm::vec3 origin = m_TransformSystem->AbsolutePosition(entity) + (transformComponent->Scale * bounds->Origin);
+		glm::vec3 volumeVector = transformComponent->Scale * bounds->VolumeVector;
+		m_Renderer->AddAABBToDraw(origin, volumeVector, (collision != nullptr && collision->CollidingEntities.size() > 0));
+	}
+#endif
+
+	auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity, "PointLight");
+	if (pointLightComponent != nullptr)	{
+		glm::vec3 position = m_TransformSystem->AbsolutePosition(entity);
+		m_Renderer->AddPointLightToDraw(
+			position, 
+			pointLightComponent->Specular,
+			pointLightComponent->Diffuse,
+			pointLightComponent->constantAttenuation,
+			pointLightComponent->linearAttenuation,
+			pointLightComponent->quadraticAttenuation,
+			pointLightComponent->spotExponent);
+	}
+
+	auto cameraComponent = m_World->GetComponent<Components::Camera>(entity, "Camera");
+	if (cameraComponent != nullptr)	{
+		m_Renderer->GetCamera()->Position(transformComponent->Position);
+		m_Renderer->GetCamera()->Orientation(transformComponent->Orientation);
+
+		m_Renderer->GetCamera()->FOV(cameraComponent->FOV);
+		m_Renderer->GetCamera()->NearClip(cameraComponent->NearClip);
+		m_Renderer->GetCamera()->FarClip(cameraComponent->FarClip);
+	}
+}
+
+void Systems::RenderSystem::Initialize()
+{
+	m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>("TransformSystem");
+}
+
+
+
+
+

src/Systems/RenderSystem.h

@@ -0,0 +1,44 @@
+#ifndef RenderSystem_h__
+#define RenderSystem_h__
+
+#include <unordered_map>
+
+#include "System.h"
+#include "Systems/TransformSystem.h"
+#include "Model.h"
+#include "Texture.h"
+#include "Components/Model.h"
+#include "Components/Transform.h"
+#include "Components/Camera.h"
+#include "Components/Bounds.h"
+#include "Components/Collision.h"
+#include "Renderer.h"
+
+namespace Systems
+{
+
+	class  RenderSystem : public System
+	{
+	public:
+		RenderSystem(World* world, std::shared_ptr<Renderer> renderer)
+			: System(world), m_Renderer(renderer){ }
+
+		void Initialize() override;
+
+		std::unordered_map<std::string, std::shared_ptr<Model>> m_CachedModels;
+
+		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;
+	};
+
+
+}
+
+
+
+
+#endif //RenderSystem_h__

src/Systems/TransformSystem.cpp

@@ -0,0 +1,48 @@
+#include "PrecompiledHeader.h"
+#include "TransformSystem.h"
+#include "World.h"
+
+//void Systems::TransformSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+//{
+//	if (parent == 0)
+//		return;
+//
+//	auto transform = m_World->GetComponent<Components::Transform>(entity, "Transform");
+//	auto parentTransform = m_World->GetComponent<Components::Transform>(parent, "Transform");
+//
+//	transform->Position = parentTransform->Position + transform->RelativePosition;
+//}
+
+glm::vec3 Systems::TransformSystem::AbsolutePosition(EntityID entity)
+{
+	glm::vec3 absPosition;
+	glm::quat accumulativeOrientation;
+
+	do
+	{
+		auto transform = m_World->GetComponent<Components::Transform>(entity, "Transform");
+		//absPosition += transform->Position;
+		entity = m_World->GetEntityParent(entity);
+		auto transform2 = m_World->GetComponent<Components::Transform>(entity, "Transform");
+		if (entity != 0)
+			absPosition += transform2->Orientation * transform->Position;
+		else
+			absPosition += transform->Position;
+	} while (entity != 0);
+
+	return absPosition * accumulativeOrientation;
+}
+
+glm::quat Systems::TransformSystem::AbsoluteOrientation(EntityID entity) 
+{
+	glm::quat absOrientation;
+
+	do
+	{
+		auto transform = m_World->GetComponent<Components::Transform>(entity, "Transform");
+		absOrientation *= transform->Orientation;
+		entity = m_World->GetEntityParent(entity);
+	} while (entity != 0);
+
+	return absOrientation;
+}

src/Systems/TransformSystem.h

@@ -0,0 +1,25 @@
+#ifndef TransformSystem_h__
+#define TransformSystem_h__
+
+#include "System.h"
+#include "Components/Transform.h"
+
+namespace Systems
+{
+
+	class TransformSystem : public System
+	{
+	public:
+		TransformSystem(World* world)
+			: System(world) { }
+
+		//void Update(double dt) override;
+		//void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+
+		glm::vec3 AbsolutePosition(EntityID entity);
+		glm::quat AbsoluteOrientation(EntityID entity);
+	};
+
+}
+
+#endif // TransformSystem_h__