• 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
  
Let's look at simple template functions and template classes

• Topic 1: Templates in ECS
  
TemplateDemo.zip

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

• 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 one 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; }

• Assignment 1: Feb 13

  Making a Checkerboard several actors parented to the board

• Topic 6: 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.


• 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)



• 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