Entity Component System part #1 (bitmask)
At the moment of writing this post, I haven't yet finished implementing sub-systems for components, even though everything else is more or less done. Since I'm still in the middle of developing it, I've decided to hold off with the other parts I wasn't yet fully sure about and start with what is already firmly in place and is the least likely to change. This is going to be a very quick update post about my method of choice for identifying and managing types of components quickly, as well as specifying requirements for sub-systems without mountains of if/else statements. The bitmask.
You might be wondering why it's beneficial to use something like that instead of a traditional way of checking with many conditionals. Well, for one, all of the information about what components an Entity has and what components a sub-system requires an Entity to have is stored in a single variable. Checking if an Entity should belong to a specific system is as easy as calling a compare method of the entity bitmask and passing in the systems requirement bitmask along with a mask for the bits we're interested in(later referred to as relevant bits). This is much more elegant, not to mention the fact that bitwise operations are cheap to perform. An ugly alternative would be making calls to some sort of method, provided by either the entity class itself or some kind of Entity/Component manager class, to check if it holds a specific type of component. Depending on the implementation and the data structure used, such method might need to iterate over tons of other components just to check if one of the desired type exists. For fairly small systems it might be an okay solution, but it does not scale well.
Before taking a look at the code, it's fair to mention that I've currently limited the number of possible components to 32. This method is expandable fairly easily though, so it shouldn't be a problem in case 32 max components don't cut it anymore. Let's take a look at the base component class first to get a better picture:
typedef unsigned char ComponentType;
class BaseComponent{
public:
BaseComponent(const ComponentType& lType) : Type(lType){}
virtual ~BaseComponent() = 0;
const ComponentType& GetType()const{ return this->Type; }
protected:
const ComponentType Type;
};
Note that I haven't yet started working on actual components, so this may change. The basic idea will remain the same though. Each component type will have a specific ID (ex. Position is 0, Velocity is 1 etc.). Only 5 bits are needed to represent a value 0-31. The closest thing to that is an unsigned char, which has a whole byte to play with, so I've chosen it to represent the component ID. Should there ever be a need to expand the number of components, the same type can still be used to represent anything from 0 to 255 thanks to the unused 3 bits.
With that covered, here's the bitmask implementation:
#include <stdint.h>
typedef int32_t BitmaskType;
struct Bitmask{
Bitmask():bits(0){}
Bitmask(BitmaskType bitmask):bits(bitmask){}
BitmaskType GetBitmask() const{ return bits; }
bool Compare(const Bitmask& Bitmask1, const BitmaskType& RelevantBits = 0) const{
return(RelevantBits ? ((Bitmask1.GetBitmask() & RelevantBits) == (this->bits & RelevantBits))
: (Bitmask1.GetBitmask() == this->bits));
}
bool GetBit(const unsigned int& n) const{ return bits&(1 << n); }
void TurnOnBit(const unsigned int& n){ bits |= 1 << n; }
void TurnOnBits(const BitmaskType& bitmask){ bits |= bitmask; }
void ClearBit(const unsigned int& n){ bits &= ~(1 << n); }
void ToggleBit(const unsigned int& n){ bits ^= 1 << n; }
void ZeroOut(){ bits = 0; }
private:
BitmaskType bits;
};
It's fairly basic, so I won't elaborate much. Essentially, it just treats a certain variable as a set of bits. In this case, the number of bits is explicitly specified in its name int32_t, supplied amongst many others, thanks to the stdint.h header. Should there ever be a need to expand the number of components, all that's necessary is changing the typedef line to refer to a data type that has more memory. Everything else here is simple binary arithmetic. For more information, see this article:
http://www.cprogramming.com/tutorial/bitwise_operators.html
ellievsbear
theartofmadeline
baratheonpilled
2087
prguitarman
andulkaphoto