ADD: Render with ECS

CMakeLists.txt

@@ -124,6 +124,18 @@ add_executable(ColorRace
         engine/src/ecs/Entity.h
         engine/src/ecs/ComponentPool.cpp
         engine/src/ecs/ComponentPool.h
+        engine/src/ecs/standardComponents/TransformComponent.h
+        engine/src/ecs/standardComponents/MeshComponent.h
+        engine/src/ecs/EntitySystem.cpp
+        engine/src/ecs/EntitySystem.h
+        engine/src/renderer/RenderSystem.cpp
+        engine/src/renderer/RenderSystem.h
+        engine/src/renderer/RenderQueue.cpp
+        engine/src/renderer/RenderQueue.h
+        engine/src/renderer/MeshRenderSystem.cpp
+        engine/src/renderer/MeshRenderSystem.h
+        engine/src/renderer/MeshRenderer.cpp
+        engine/src/renderer/MeshRenderer.h
 
 )
 

engine/src/ecs/EntitySystem.cpp

@@ -0,0 +1,5 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#include "EntitySystem.h"

engine/src/ecs/EntitySystem.h

@@ -0,0 +1,18 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#ifndef COLORRACE_ENTITYSYSTEM_H
+#define COLORRACE_ENTITYSYSTEM_H
+#include "EntityRegistry.h"
+
+
+class EntitySystem {
+public:
+    virtual ~EntitySystem() = default;
+
+    virtual void update(engine::EntityRegistry& registry, float deltaTime) = 0;
+};
+
+
+#endif //COLORRACE_ENTITYSYSTEM_H

engine/src/ecs/standardComponents/MeshComponent.h

@@ -0,0 +1,16 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#ifndef COLORRACE_MESHCOMPONENT_H
+#define COLORRACE_MESHCOMPONENT_H
+#include <memory>
+
+#include "renderer/model/RawModel.h"
+
+namespace engine {
+    struct MeshComponent {
+        std::shared_ptr<engine::RawModel> raw_model;
+    };
+}
+#endif //COLORRACE_MESHCOMPONENT_H

engine/src/ecs/standardComponents/TransformComponent.h

@@ -0,0 +1,28 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#ifndef COLORRACE_TRANSFORMCOMPONENT_H
+#define COLORRACE_TRANSFORMCOMPONENT_H
+#include "glm/glm.hpp"
+#include <glm/gtc/matrix_transform.hpp>
+
+namespace engine {
+    struct TransformComponent {
+        glm::vec3 m_position;
+        glm::vec3 m_rotation;
+        glm::vec3 m_scale;
+
+        [[nodiscard]] glm::mat4 computeModelMatrix() const {
+            auto modelMatrix = glm::mat4(1.0f);
+            modelMatrix = glm::translate(modelMatrix, m_position);
+            modelMatrix = glm::rotate(modelMatrix, glm::radians(m_rotation.x), {1.0f, 0.0f, 0.0f});
+            modelMatrix = glm::rotate(modelMatrix, glm::radians(m_rotation.y), {0.0f, 1.0f, 0.0f});
+            modelMatrix = glm::rotate(modelMatrix, glm::radians(m_rotation.z), {0.0f, 0.0f, 1.0f});
+            modelMatrix = glm::scale(modelMatrix, m_scale);
+            return modelMatrix;
+        }
+    };
+
+}
+#endif //COLORRACE_TRANSFORMCOMPONENT_H

engine/src/renderer/MeshRenderSystem.cpp

@@ -0,0 +1,24 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#include "MeshRenderSystem.h"
+
+#include "ecs/standardComponents/MeshComponent.h"
+#include "ecs/standardComponents/TransformComponent.h"
+
+
+void engine::MeshRenderSystem::update(engine::EntityRegistry &registry, engine::RenderQueue &renderQueue) {
+    auto transforms = registry.getPool<engine::TransformComponent>();
+    auto meshes = registry.getPool<engine::MeshComponent>();
+
+    for (auto& [entity, mesh] : meshes)
+    {
+        if (!transforms.has(entity))
+            continue;
+
+        auto& transform = transforms.get(entity);
+
+        renderQueue.submit(engine::RenderCommand(mesh.raw_model, transform.computeModelMatrix()));
+    }
+}

engine/src/renderer/MeshRenderSystem.h

@@ -0,0 +1,18 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#ifndef COLORRACE_MESHRENDERSYSTEM_H
+#define COLORRACE_MESHRENDERSYSTEM_H
+#include "RenderSystem.h"
+
+
+namespace engine {
+    class MeshRenderSystem : public engine::RenderSystem {
+    public:
+        void update(engine::EntityRegistry &registry, engine::RenderQueue &renderQueue) override;
+    };
+
+}
+
+#endif //COLORRACE_MESHRENDERSYSTEM_H

engine/src/renderer/MeshRenderer.cpp

@@ -0,0 +1,21 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#include "MeshRenderer.h"
+
+void engine::MeshRenderer::render(RenderQueue &queue, const Camera &camera) {
+    m_shader->start();
+    m_shader->loadViewMatrix(camera.getViewMatrix());
+    m_shader->loadProjectionMatrix(camera.getProjectionMatrix());
+
+    for (const auto&[mesh, transformationMatrix] : queue.getRenderCommands()) {
+        m_shader->loadTransformationMatrix(transformationMatrix);
+
+        mesh->bind();
+        mesh->draw();
+        mesh->unbind();
+    }
+
+    m_shader->stop();
+}

engine/src/renderer/MeshRenderer.h

@@ -0,0 +1,23 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#ifndef COLORRACE_MESHRENDERER_H
+#define COLORRACE_MESHRENDERER_H
+#include "RenderQueue.h"
+#include "entities/Camera.h"
+#include "shader/StaticShader.h"
+
+
+namespace engine {
+    class MeshRenderer {
+    public:
+        MeshRenderer() : m_shader(std::make_unique<StaticShader>()) {}
+        void render(RenderQueue& queue, const Camera& camera);
+    private:
+        std::unique_ptr<StaticShader> m_shader;
+    };
+
+}
+
+#endif //COLORRACE_MESHRENDERER_H

engine/src/renderer/RenderQueue.cpp

@@ -0,0 +1,5 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#include "RenderQueue.h"

engine/src/renderer/RenderQueue.h

@@ -0,0 +1,39 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#ifndef COLORRACE_RENDERQUEUE_H
+#define COLORRACE_RENDERQUEUE_H
+#include <memory>
+
+#include "glm/glm.hpp"
+#include "model/RawModel.h"
+
+namespace engine {
+    struct RenderCommand {
+        std::shared_ptr<engine::RawModel> mesh;
+        glm::mat4 transformationMatrix;
+    };
+
+    class RenderQueue {
+    public:
+        void submit(RenderCommand cmd) {
+            m_renderCommands.push_back(std::move(cmd));
+        }
+
+        [[nodiscard]] const auto& getRenderCommands() const {
+            return m_renderCommands;
+        }
+
+        void clear() {
+            m_renderCommands.clear();
+        }
+
+    private:
+        std::vector<RenderCommand> m_renderCommands;
+    };
+}
+
+
+
+#endif //COLORRACE_RENDERQUEUE_H

engine/src/renderer/RenderSystem.cpp

@@ -0,0 +1,5 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#include "RenderSystem.h"

engine/src/renderer/RenderSystem.h

@@ -0,0 +1,21 @@
+//
+// Created by sebastian on 29.07.26.
+//
+
+#ifndef COLORRACE_RENDERSYSTEM_H
+#define COLORRACE_RENDERSYSTEM_H
+#include "RenderQueue.h"
+#include "ecs/EntityRegistry.h"
+
+
+namespace engine {
+    class RenderSystem {
+    public:
+        virtual ~RenderSystem() = default;
+        virtual void update(EntityRegistry& registry, RenderQueue& renderQueue) = 0;
+
+    };
+}
+
+
+#endif //COLORRACE_RENDERSYSTEM_H

game/src/ColorRaceApp.cpp

@@ -7,21 +7,22 @@
 #include <iostream>
 #include <ostream>
 
+#include "renderer/MeshRenderSystem.h"
+#include "renderer/RenderSystem.h"
 
 
 void ColorRaceApp::onUpdate(float deltaTime) {
-    m_cubeEntity->increaseRotation(glm::vec3(0, 1, 0));
+
 }
 
 void ColorRaceApp::onRender() {
     m_renderState.apply();
 
-    m_shader->start();
+    engine::MeshRenderSystem meshRenderSystem;
-    m_shader->loadTransformationMatrix(m_cubeEntity->getModelMatrix());
+
-    m_shader->loadViewMatrix(m_camera->getViewMatrix());
+    engine::RenderQueue queue;
-    m_shader->loadProjectionMatrix(m_camera->getProjectionMatrix());
+    meshRenderSystem.update(*entityRegistry, queue);
-    m_cubeEntity->getModel().bind();
+
-    m_cubeEntity->getModel().draw();
+    m_renderer->render(queue, *m_camera);
-    m_cubeEntity->getModel().unbind();
+
-    m_shader->stop();
 }

game/src/ColorRaceApp.h

@@ -5,7 +5,10 @@
 #ifndef COLORRACE_COLORRACEAPP_H
 #define COLORRACE_COLORRACEAPP_H
 #include "core/Application.h"
-#include "../../engine/src/renderer/entities/Entity.h"
+#include "ecs/EntityRegistry.h"
+#include "ecs/standardComponents/MeshComponent.h"
+#include "ecs/standardComponents/TransformComponent.h"
+#include "renderer/MeshRenderer.h"
 #include "renderer/entities/Camera.h"
 #include "renderer/primitives/CubeFactory.h"
 #include "renderer/shader/StaticShader.h"
@@ -38,12 +41,23 @@ public:
         m_camera->setPitch(0.0f);
 
         auto cubeModel = engine::CubeFactory::createCube();
-        m_cubeEntity = std::make_unique<engine::Entity>(cubeModel);
+
+        entityRegistry = std::make_unique<engine::EntityRegistry>();
+
+        const auto transformComponent = engine::TransformComponent({0,0,0}, {0,0,0}, {1,1,1});
+        const auto meshComponent = engine::MeshComponent(std::move(cubeModel));
+
+        const auto entity = entityRegistry->createEntity();
+        entityRegistry->addComponent<>(entity, transformComponent);
+        entityRegistry->addComponent(entity, meshComponent);
+
+        m_renderer = std::make_unique<engine::MeshRenderer>();
     }
 private:
     engine::GLRenderState m_renderState;
+    std::unique_ptr<engine::EntityRegistry> entityRegistry;
     std::unique_ptr<engine::StaticShader> m_shader;
-    std::unique_ptr<engine::Entity> m_cubeEntity;
+    std::unique_ptr<engine::MeshRenderer> m_renderer;
     std::unique_ptr<engine::Camera> m_camera;
 protected:
     void onUpdate(float deltaTime) override;