• Home
  
• My schedule
  
• About me
  
• /etc
  

Welcome to Game 258 - Game Engines 4

ECS Entity Component System

• Topic 0: Templates in C++ and other tools
  
I did some demos in that horrible classroom last week.
The first was just to show you a templated function. The next was to templete a class.
TemplateDemo.zip
I finished by starting the code for an abstract class called Component.
I made the argument, no one objected, that I could create a class called Actor that inherits from Component.
This a version of our real starting point ComponentFramework25.0.0,
download it. We will start by incorporating the demo project into the FrameWork.

My next big step is to explain this: /// See universal references in C++11 template<typename ComponentTemplate, typename ... Args> void AddComponent(Args&& ... args_) { ComponentTemplate* componentObject = new ComponentTemplate(std::forward<Args>(args_)...); components.push_back(componentObject); }
• Topic 1: The Entity (Actor / Component)
Using the Actor/Component demo code we created over the last one or two classes, begin inserting these ideas in to the framework - I will guide you, promise.

• Topic 2: The Components and Actors
Let's create some basic components and begin to flesh them out: TransformComponent, MeshComponent, Actor, and CameraActor.


This is where we sould all be now as of Jan 31 2025:
Component.h
I appoligize that I didn't cover Actor properly, I hope you all just distracted me and not because of a feeble brain.
I will explain in full detail
Actor.h
Actor.cpp
MeshComponent.h
MeshComponent.cpp
ShaderComponent.h
ShaderComponent.cpp
MaterialComponent.h
MaterialComponent.cpp
TransformComponent.h
TransformComponent.cpp


• Topic 3: Using the Components
In Let's start using the components with the actors

• Topic 4: Using Components to render an Actor in 3D. (Finally some graphics)
Get Mario on the screen!

• Topic 5: Parenting objects
Once you have mario on the screen, I need you to make the following modification to the Actor class: Matrix4 Actor::GetModelMatrix() { TransformComponent* transform = GetComponent<TransformComponent>(); if (transform) { modelMatrix = transform->GetTransformMatrix(); } else { modelMatrix.loadIdentity(); } if (parent) { /// <== LOOK AT IT! Think! modelMatrix = dynamic_cast<Actor*>(parent)->GetModelMatrix() * modelMatrix; } return modelMatrix; } </Actor*></TransformComponent>

From here you could parent one actor to another. On the website I have a hammer.obj and a texture for it. Can you put the hammer in Mario's hand and have it move with him?

• Assignment 1: Feb 23

  Making a Checkerboard with Checkers

• Topic 7: Better Memory Management - Smart Pointers
In this next section, I'll show you how smart pointers work, and in our current application, how shared_ptr can be helpful.

In this next section, we'll look at unique_ptr, weak_ptr, and why everything should at least be a shared_ptr.


• Topic 8: Better, better Memory Management - Applying smart pointers to the engine
Based on what we did last week, let's use the following code definition, in the Componentt.h file

template<typename T> using Ref = std::shared_ptr<T>;
You'll need to place #include header file at the top.



Next, we'll need to modifly the Actor.h file a bit to handle this new Ref() definition. I can use the std::make_shared idea plus simplify the existing code to look like this:
template<typename ComponentTemplate> void AddComponent(Ref<ComponentTemplate> component_) { if (GetComponent<ComponentTemplate>().get() != nullptr) { #ifdef _DEBUG std::cerr << "WARNING: Trying to add a component type that is already added - ignored\n"; #endif return; } components.push_back(component_); }

Delete all the old AddComponent() stuff and add the new stuff to your project.
We will also need to write a overload the AddComponent() method to accept an already existing component. This will be necessary for the implimentation of the asset manager. This overload will look very much like the one listed above. The easiest approch is just to copy the original and make this simple modification.
template<typename ComponentTemplate, typename ... Args> void AddComponent(Args&& ... args_) { /// before you add the component ask if you have the component in the list already, /// if so - don't add a second one. if (GetComponent<ComponentTemplate>().get() != nullptr) { #ifdef _DEBUG std::cerr << "WARNING: Trying to add a component type that is already added - ignored\n"; #endif return; } /// Finish building the component and add the component to the list components.push_back(std::make_shared<ComponentTemplate>(std::forward<Args>(args_)...)); }

Now you are going to need a new GetComponent as well
template<typename ComponentTemplate> Ref<ComponentTemplate> GetComponent() const { for (auto component : components) { if (dynamic_cast<ComponentTemplate*>(component.get())) { /// This is a dynamic cast designed for shared_ptr's /// https://en.cppreference.com/w/cpp/memory/shared_ptr/pointer_cast return std::dynamic_pointer_cast<ComponentTemplate>(component); } } return Ref<ComponentTemplate>(nullptr); } Now on to Actor.cpp, replace RemoveAllComponents() with
template<typename ComponentTemplate> void Actor::RemoveAllComponents() { components.clear(); } In GetModelMatrix() you will only need to change one line. This will be the first time you'll use a Ref to a component.
Ref transform = GetComponent();
Get it?


• Assignment 2: Switch from raw pointers to all Refs (shared_ptr) Due Mar 21



• Topic 9:Systems
  So far we have looked at Entities (Actors), and Components. Now let's look at the third part - Systems.
  To start off with, let's look at collisions. In Unity and Unreal they call them colliders.
  Let's start by creating a ColliderComponent.

  This is the starting point of the of the collision system. First, define ColliderComponent. This just holds the type of collision object you actor is using, sphere, AABB, and such. Here's the basic code for the Component.
  #pragma once #include "TransformComponent.h" #include <Plane.h> using namespace MATHEX; enum class ColliderType { SPHERE, AABB, PLANE, }; /// For an Axis Aligned Bounding Box, their are many ways you could define the box. /// My favorite way, the easiest to understand way is pick the center location of /// the box, then specify the radius from that center in /// the x, y,and z dimensions. Umer calls the radius the halfExtent struct AABB { Vec3 center; Vec3 halfExtents; }; class CollisionComponent: public Component { friend class CollisionSystem; CollisionComponent(const CollisionComponent&) = delete; CollisionComponent(CollisionComponent&&) = delete; CollisionComponent& operator = (const CollisionComponent&) = delete; CollisionComponent& operator = (CollisionComponent&&) = delete; protected: ColliderType colliderType; float radius; /// Sphere collision Vec3 halfExtents; /// AABB Plane plane; /// Plane public: CollisionComponent(Component* parent_, float radius_ ); CollisionComponent(Component* parent_, Vec3 halfExtents_); CollisionComponent(Component* parent_, Plane plane_); bool OnCreate(){return true;} void OnDestroy(){} void Update(const float deltaTime_){} void Render()const{} };

  Next, let me build a Collision System. Here's the header file:
  #pragma once #include <vector> #include "CollisionComponent.h" #include "PhysicsComponent.h" #include "Actor.h" #include "Debug.h" #include <Sphere.h> using namespace MATH; using namespace MATHEX; class CollisionSystem { private: std::vector<Ref<Actor>> collidingActors; public: /// This function will check the the actor being added is new and has the all proper components void AddActor(Ref<Actor> actor_) { if(actor_->GetComponent<CollisionComponent>().get() == nullptr){ Debug::Error("The Actor must have a CollisionComponent - ignored ", __FILE__, __LINE__); return; } if(actor_->GetComponent<PhysicsComponent>().get() == nullptr){ Debug::Error("The Actor must have a PhysicsComponent - ignored ", __FILE__, __LINE__); return; } collidingActors.push_back(actor_); } bool CollisionDetection(const Sphere &s1, const Sphere &s2) const; bool CollisionDetection(const AABB &bb1, const AABB &bb2) const; bool CollisionDetection(const Sphere s1, const Plane p1) const; void Update(const float deltaTime); };

  We will flesh these out in class. Be sure to show up.

• Assignment 3: Collision System