How can I have parent-child transform in a component system?

Question

Before when using inheritance, I could draw all my objects using this recursive function:

void Object::innerDraw(sf::RenderTarget& target, sf::RenderStates states)
{
    states.transform *= Object::getTransform(); //translate by this object's position
    this->Draw(target, states); //draw this object
    for (Object *child : m_children)
    {
        if(child->isVisible)
            child->innerDraw(target, states); //draw all children
    }
}

However, I am now looking at a component design where the graphics component pushes it's sprite to the renderer Renderer::toDraw.push_back(&sprite);

The renderer then draws all the sprites in it's container

for (sf::Drawable *Entity : toDraw)
{
    target.draw(*Entity, state); // (state isn't doing any transforming here)
}

How can I be able to draw things relative to parents position?

Answer 1

Component-based entity systems are often about removing inheritance of type (and providing a nice means to drive things from data, although that aspect of things is not particularly relevant to this question).

That is, not having a very deep class hierarchy where everything in your game (tanks, bullets, space ships, whatever) exist in one large "family tree" of classes. It does not mean you need to remove logical parent/child relationships from your game.

In this case, you can implement the kind of hierarchical transformation approach in exactly the same way, either by having the renderable components have a transformation hierarchy themselves or simply having the renderable components contain a reference to a sprite which uses the existing transform hierarchy you outlined in your question -- this, in fact, would let you keep the bulk processing logic for those components in your renderer itself, where is could be in general more localized/cache-coherent and potentially better for parallelization (unlikely with rendering, but usually true for other subsystems or the subsystems themselves). See also the outboard component architectural approach.

Answer 2

You most probably need a complex transform state tree/cache system. You can start by adding a "parent" member to the transform object. Implementation pretty much depends on what you already have there so there's not much I can help with.

OR

You could go back to a system where you know how it's done (at least to that part of it). Why did you move away from it?

Answer 3

The easiest and most obvious way will work well enough:

Make a "parent relationship" component and attach it to your entities. Then in the transform calculation step, recursively calculate the parent transform.

If you want to improve efficiency, save a time stamp or frame counter with the parent entity so that you don't need to compute the parent transform more than once per frame.

Answer 4

I've got the feeling you might be misinterpreting what a component-system is about.

Here is an excellent article about this.

An ECM-system is meant to avoid the child-parent spaghetti between code-objects that inherit from each other, not between game-objects.

This has nothing to do with transforms. If you have a character and you want to move his head in relation to the body, you still need some form of parent/child relationship between them and a scene-graph or transform-stack that couples their position and orientation together.

For your example you could rewrite your renderer to apply the transforms itself and call *push_back* like this

void Object::innerDraw(sf::RenderTarget& target, Transform & parentTransform)
{
    Transform myTransform = parentTransform * Object::getTransform();
    Renderer::toDraw.push_back(&sprite, myTransform);
    for (Object *child : m_children)
    {
        if(child->isVisible)
            child->innerDraw(target, myTransform); //draw all children
    }
}

But I would probably prefer to keep it as it is and not.

(Note, that Transform is just a guess, I don't know how they're actually called in SFML)