Game Engine Architecture - ECS

class Player {
    Vector2 position;
    int health;

    void Move(Vector2 direction) {
        position += direction;
    }

    void TakeDamage(int damage) {
        health -= damage;
    }
}

// Component 구조체 정의
struct Position {
    float x, y;
};

struct Velocity {
    float dx, dy;
};

// Entity 구조 예시
struct Entity {
    int id;
    Position* position;
    Velocity* velocity;
};

// System 함수: 상태를 바꿈
void MovementSystem(std::vector<Entity>& entities) {
    for (auto& e : entities) {
        if (e.position && e.velocity) {
            e.position->x += e.velocity->dx;
            e.position->y += e.velocity->dy;
        }
    }
}

const auto pos = dense.size();
dense.push_back(element);
sparse[element] = pos;

const auto last = dense.back();
swap(dense.back(), dense[sparse[element]]);
swap(sparse[last], sparse[element]);
dense.pop_back();

/**
 * @struct IDComponent
 * @brief 개체(Entity)의 고유 ID를 저장하는 컴포넌트.
 */
struct IDComponent
{
	UUID m_ID;

	IDComponent() = default;
	IDComponent(const IDComponent &) = default;
};

/**
 * @struct TagComponent
 * @brief 개체(Entity)의 태그(이름) 및 활성 상태를 저장하는 컴포넌트.
 */
struct TagComponent
{
	std::string m_Tag;
	bool m_isActive = true;	  // 에디터 상 활성 여부
	bool m_selfActive = true; // 부모와 관계없이 자신의 활성 여부

	TagComponent() = default;
	TagComponent(const TagComponent &) = default;
	TagComponent(const std::string &tag) : m_Tag(tag)
	{
	}
};

/**
 * @struct TransformComponent
 * @brief 개체의 위치, 회전, 크기 정보를 저장하는 컴포넌트.
 */
struct TransformComponent
{
	// 속성
	alglm::vec3 m_Position = {0.0f, 0.0f, 0.0f};
	alglm::vec3 m_Rotation = {0.0f, 0.0f, 0.0f};
	alglm::vec3 m_Scale = {1.0f, 1.0f, 1.0f};
	alglm::vec3 m_LastPosition = {0.0f, 0.0f, 0.0f};
	alglm::vec3 m_LastScale = {0.0f, 0.0f, 0.0f};

	bool m_isMoved = false;

	alglm::mat4 m_WorldTransform = alglm::mat4(1.0f);

	// 생성자
	TransformComponent() = default;
	TransformComponent(const TransformComponent &) = default;
	TransformComponent(const alglm::vec3 &position) : m_Position(position), m_LastPosition(position)
	{
	}

	alglm::mat4 getTransform() const
	{
		alglm::mat4 rotation = alglm::toMat4(alglm::quat(m_Rotation));

		return alglm::translate(alglm::mat4(1.0f), m_Position) * rotation * alglm::scale(alglm::mat4(1.0f), m_Scale);
	}

	float getMaxScale()
	{
		return std::max(m_Scale.x, std::max(m_Scale.y, m_Scale.z));
	}
};

/**
 * @struct MeshRendererComponent
 * @brief 메시 렌더링을 위한 컴포넌트.
 */
struct MeshRendererComponent
{
	std::shared_ptr<RenderingComponent> m_RenderingComponent;
	uint32_t type;
	std::string path = "";
	std::string matPath = "";
	bool isMatChanged = false;

	// Culling
	int32_t nodeId = NULL_NODE;
	CullSphere cullSphere;
	ECullState cullState;

	MeshRendererComponent() = default;
	MeshRendererComponent(const MeshRendererComponent &) = default;
};

struct RigidbodyComponent
{
	// FLAG
	alglm::vec3 m_FreezePos = {1, 1, 1};
	alglm::vec3 m_FreezeRot = {1, 1, 1};

	void *body = nullptr;

	/**
	 * @enum EBodyType
	 * @brief 리지드바디의 유형을 정의하는 열거형.
	 */
	enum class EBodyType
	{
		Static = 0,
		Dynamic,
		Kinematic
	};
	EBodyType m_Type = EBodyType::Dynamic;

	float m_Mass = 1.0f;
	float m_Damping = 0.001f;
	float m_AngularDamping = 0.001f;
	bool m_UseGravity = true;
	int32_t m_TouchNum = 0;

	RigidbodyComponent() = default;
	RigidbodyComponent(const RigidbodyComponent &) = default;
};

/**
 * @struct BoxColliderComponent
 * @brief 박스 콜라이더 설정을 위한 컴포넌트.
 */
struct BoxColliderComponent
{
	alglm::vec3 m_Center = {0.0f, 0.0f, 0.0f};
	alglm::vec3 m_Size = {1.0f, 1.0f, 1.0f};
	bool m_IsTrigger = false;
	bool m_IsActive = false;
	std::shared_ptr<ShaderResourceManager> m_colliderShaderResourceManager;

	float m_Friction = 0.7f;
	float m_Restitution = 0.4f;

	BoxColliderComponent() = default;
	BoxColliderComponent(const BoxColliderComponent &) = default;
};

/**
 * @struct RelationshipComponent
 * @brief 개체 간의 부모-자식 관계를 정의하는 컴포넌트.
 */
struct RelationshipComponent
{
	entt::entity parent = entt::null;
	std::vector<entt::entity> children;

	RelationshipComponent() = default;
	RelationshipComponent(const RelationshipComponent &) = default;
};

class Entity
{
    // ...

	/**
	 * @brief 새로운 컴포넌트를 추가합니다.
	 * @tparam T 추가할 컴포넌트 타입.
	 * @tparam Args 컴포넌트 생성자에 전달할 인자들.
	 * @param args 컴포넌트 생성자 인자.
	 * @return T& 추가된 컴포넌트의 참조.
	 */
	template <typename T, typename... Args> T &addComponent(Args &&...args)
	{
		T &component = m_Scene->m_Registry.emplace<T>(m_EntityHandle, std::forward<Args>(args)...);
		m_Scene->onComponentAdded<T>(*this, component);
		return component;
	}

	/**
	 * @brief 컴포넌트를 추가하거나 기존 컴포넌트를 교체합니다.
	 * @tparam T 추가 또는 교체할 컴포넌트 타입.
	 * @tparam Args 컴포넌트 생성자에 전달할 인자들.
	 * @param args 컴포넌트 생성자 인자.
	 * @return T& 추가되거나 교체된 컴포넌트의 참조.
	 */
	template <typename T, typename... Args> T &addOrReplaceComponent(Args &&...args)
	{
		T &component = m_Scene->m_Registry.emplace_or_replace<T>(m_EntityHandle, std::forward<Args>(args)...);
		m_Scene->onComponentAdded<T>(*this, component);
		return component;
	}

	/**
	 * @brief 특정 타입의 컴포넌트를 가져옵니다.
	 * @tparam T 가져올 컴포넌트 타입.
	 * @return T& 요청된 컴포넌트의 참조.
	 */
	template <typename T> T &getComponent()
	{
		// ASSERT HAS COMPONENT
		return m_Scene->m_Registry.get<T>(m_EntityHandle);
	}

	/**
	 * @brief 특정 타입의 컴포넌트를 제거합니다.
	 * @tparam T 제거할 컴포넌트 타입.
	 */
	template <typename T> void removeComponent()
	{
		// ASSERT HAS COMPONENT
		m_Scene->m_Registry.remove<T>(m_EntityHandle);
	}

	/**
	 * @brief 엔티티가 특정 컴포넌트를 가지고 있는지 확인합니다.
	 * @tparam T 확인할 컴포넌트 타입.
	 * @return true 컴포넌트를 가지고 있음.
	 * @return false 컴포넌트를 가지고 있지 않음.
	 */
	template <typename T> bool hasComponent()
	{
		return m_Scene->m_Registry.all_of<T>(m_EntityHandle);
	}

    // ...
};

/**
* @brief BoxColliderComponent의 특수화된 삭제 함수.
*/
template <> void removeComponent<BoxColliderComponent>()
{
    // ShaderResourceManager 정리 작업 따로!
    m_Scene->removeColliderShaderResourceManager(*this);
    m_Scene->m_Registry.remove<BoxColliderComponent>(m_EntityHandle);
}

/**
* @brief 특정 컴포넌트를 가진 모든 엔티티를 가져옵니다.
* @tparam Components 검색할 컴포넌트들.
* @return auto 컴포넌트를 가진 엔티티 뷰.
*/
template <typename... Components> auto getAllEntitiesWith()
{
    return m_Registry.view<Components...>();
}

// Render 함수

// Transform, Tag, MeshRenderer Component를 가져온다.
auto &view = scene->getAllEntitiesWith<TransformComponent, TagComponent, MeshRendererComponent>();
for (auto &entity : view)
{
    // 활성화 버튼이 눌렸거나 MeshType이 None이면 렌더링하지 않는다.
    if (!view.get<TagComponent>(entity).m_isActive || view.get<MeshRendererComponent>(entity).type == 0)
    {
        continue;
    }

    MeshRendererComponent &meshRendererComponent = view.get<MeshRendererComponent>(entity);
    
    // Cull State를 확인해, 렌더링 대상이 아니면 렌더링하지 않는다.
    if (meshRendererComponent.cullState != ECullState::RENDER)
    {
        continue;
    }
    drawInfo.model = view.get<TransformComponent>(entity).m_WorldTransform;
    if (auto *sa = scene->tryGet<SkeletalAnimatorComponent>(entity)) // SA 컴포넌트 있으면 데이터 전달
    {
        auto *sac = (SAComponent *)sa->sac.get();
        std::vector<alglm::mat4> matrices = sac->getCurrentPose();

        for (size_t i = 0; i < matrices.size(); ++i)
            drawInfo.finalBonesMatrices[i] = matrices[i];
    }
    else
    {
        for (size_t i = 0; i < MAX_BONES; ++i) // 항등행렬 초기화
        drawInfo.finalBonesMatrices[i] = alglm::mat4(1.0f);
    }

    // Draw 호출을 한다
    meshRendererComponent.m_RenderingComponent->draw(drawInfo);
}