entity.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2025-2026 Arnis Lektauers
//
// Created by Arnis Lektauers on 05.09.2025.
//
#pragma once
 
#include <memory>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
#include "components/componentSystemRegistry.h"
#include "components/script/scriptComponent.h"
#include "engine.h"
#include "components/component.h"
#include "scene/graphNode.h"
 
namespace visutwin::canvas
{
    class ScriptComponent;

    class Entity : public GraphNode
    {
    public:
        virtual ~Entity();
 
        Component* addComponentInstance(std::unique_ptr<Component> component, ComponentTypeID typeId)
        {
            if (!component) {
                return nullptr;
            }
            if (const auto it = _components.find(typeId); it != _components.end()) {
                return it->second;
            }
 
            auto* raw = component.get();
            _components[typeId] = raw;
            _componentStorage.push_back(std::move(component));
 
            if (typeId == componentTypeID<ScriptComponent>()) {
                _script = static_cast<ScriptComponent*>(raw);
            }
 
            return raw;
        }
 
        template <class ComponentType>
        Component* addComponent()
        {
            const ComponentTypeID typeId = componentTypeID<ComponentType>();
            if (const auto it = _components.find(typeId); it != _components.end()) {
                return it->second;
            }
 
            if (!_engine || !_engine->systems()) {
                return nullptr;
            }
 
            auto* system = _engine->systems()->template getByComponentType<ComponentType>();
            if (!system) {
                return nullptr;
            }
 
            auto component = system->addComponent(this);
            if (!component) {
                return nullptr;
            }
 
            auto* raw = component.get();
            _components[typeId] = raw;
            _componentStorage.push_back(std::move(component));
 
            if constexpr (std::is_same_v<ComponentType, ScriptComponent>) {
                _script = static_cast<ScriptComponent*>(raw);
            }
 
            return raw;
        }

        template <class T>
        requires std::derived_from<T, Component>
        T* findComponent()
        {
            auto it = _components.find(componentTypeID<T>());
            if (it == _components.end()) {
                return nullptr;
            }
            return static_cast<T*>(it->second);
        }

        template <class T>
        requires std::derived_from<T, Component>
        std::vector<T*> findComponents()
        {
            std::vector<T*> result;
            auto it = _components.find(componentTypeID<T>());
            if (it == _components.end())
            {
                return result;
            }
            result.push_back(static_cast<T*>(it->second));
            return result;
        }
 
        ScriptComponent* script() const { return _script; }
 
        Engine* engine() const { return _engine; }
        void setEngine(Engine* engine) { _engine = engine; }

        void onHierarchyStateChanged(bool enabled) override;

        Entity* clone() const;

        const std::unordered_map<ComponentTypeID, Component*>& components() const { return _components; }

        Engine* findEngine() const;
 
    private:
        Engine* _engine = nullptr;
 
        // Component map for generic access
        std::unordered_map<ComponentTypeID, Component*> _components;
        std::vector<std::unique_ptr<Component>> _componentStorage;
 
        ScriptComponent* _script = nullptr;
    };
}