Jump to content

  • Log In with Google      Sign In   
  • Create Account





ComponentManager v ComponentMapper: Dawn of Components

Posted by TheChubu, 25 July 2014 · 658 views

dustArtemis artemis ecs entity component system java
ComponentManager v ComponentMapper: Dawn of Components Do you know in which results page dustArtemis appears if you search for “artemis framework” in Google? Absolutely in none of them! So we're going to celebrate by talking about the ComponentManager class.



dustArtemis


dustArtemis is a fork of Artemis Entity System, which is a BSD-licenced small Java framework for setting up Entities, Components and Systems.

(to be fair if you google “artemis fork” its there like in the eight result but I doubt anyone Googles for forks exclusively, spoons on the other hand...)

Components, components, components!

ComponentManager is what it sounds like, it manages components in a way that isn't very memory efficient, but its quite fast for adding, removing and retrieving components.

It holds a Bag for each Component type there is. That means that in a single vector(ish) collection you have all the components of that type.

This makes it rather fast and easy to access components IF you know their index, and it happens that their index into the Bag is exactly the ID number of the Entity owner of that Component, how convenient!

The protagonists

Artemis organizes it in two classes really:

ComponentMapper is what EntitySystems use to access components when iterating over entities. All that is needed is a simple get() to have your component ready to use.
void process ( Entity e ) {
SomeComponent cmp = someComponentMapper.get(e.id);
doMagic(cmp);
}
There, direct index lookup, all the O(1) glory you can muster.

Now, ComponentMapper is just a thin veil over a particular bag of components that, as I described, originate from ComponentManager actually. Since ComponentMapper is used for access, ComponentManager's purpose is mainly adding and removal of components.
protected void addComponent ( final Entity e, final Component component ) {
    final int cmpIndex = ClassIndexer.getIndexFor( component.getClass(), Component.class );
    initIfAbsent( cmpIndex ).add( e.id, component );
    e.componentBits.set( cmpIndex );
}

protected void removeComponent ( final Entity e, final Class<? extends Component> type ) {
    final int cmpIndex = ClassIndexer.getIndexFor( type, Component.class );
    final BitSet componentBits = e.componentBits;
    // if entity has such component 
    if ( componentBits.get( cmpIndex ) ) {
        componentsByType.getUnsafe( cmpIndex ).removeUnsafe( e.id );
        componentBits.clear( cmpIndex );
    }
}
Adding and removing components is a tiny bit more complex since what you know at the moment is the component's class, not its index.

All the indices!

Here it comes my own addition, ClassIndexer. ClassIndexer just does one rather simple thing, given a superclass, it indexes incrementally the provided subclass. So each subclass of Component will have its own incremental index. Since those indices are the ones we use to find the corresponding Component Bag, they can't be any value, so they start from 0.

This process involves a hash lookup, and in case you use it for something else, ClassIndexer is prepared for multithreaded access (original idea was to be able to create Entity instances on different threads but that idea fell through once I started to see all the side effects I'd have to take care of).

It was the same cost for original Artemis (well, HashMap lookup instead of ConcurrentHashMap lookup) except Artemis had two separate ways of dealing with the indexing for EntitySystems and Components (specialized inner class and ComponentType respectively), I just removed that code and made a single point where both get their indices.

I can probably jiggle things a bit around and get rid of it for this particular case (off the top of my head, HashMap<Class<? extends Component>, Bag<Component>>) but there are a few more places where indices per Component type are used.

After that, its smooth sailing, access directly by index, clear or set the corresponding component type bit in the Entity for removal/addition respectively (so EntitySystems can know if they're still interested in the Entity), and you're good to go.


Pre-emptive initialization

There is also another small addition of mine here, while fixing a few null pointer exceptions in this class, I choose to eagerly initialize the bags in 'componentsByType' so not to do null checks every single time.
private final BoundedBag<Component> initIfAbsent ( final int cmpIndex ) {
    final int prevCap = componentsByType.capacity();
    // If type bag can't hold this component type.
    if ( cmpIndex >= prevCap ) {
        componentsByType.ensureCapacity( cmpIndex );
        // Init all the missing bags.
        for ( int i = componentsByType.capacity(); i-- > prevCap; ) {
            componentsByType.setUnsafe( i, new BoundedBag<>( Component.class, 4 ) );
        }
    }
    return componentsByType.getUnsafe( cmpIndex );
}
Those branches are taken very few times, HotSpot can “prune” them when JITting the methods.

The End... Or is it?

Well, thats it for now, next entry I'll discuss a bit the issues with the "index by Entity ID" approach that I've encountered. Cya!





December 2014 »

S M T W T F S
 123456
78910111213
14151617181920
21 22 2324252627
28293031   

Recent Comments

PARTNERS