如何在C ++中实现一个场景图，其中每个场景节点都可以引用多个子场景节点

Question

I'm currently trying to port my game engine from Java to C++ so that I use more up-to-date versions of OpenGL. While it has generally been a very smooth process (despite having very minimal experience with C++), I ran into problems when trying to port my SceneNode class.

The SceneNode class is used to create a Scene Graph by storing a parent node and a collection of children nodes as members. In Java, it is fine for a SceneNode to have another SceneNode (such as a child node) as a member. However, this is not possible in C++ without using pointers for example.

So, my question basically boils down to: What would be the recommended way to store a (or a collection of) SceneNode as a member of another SceneNode?

Below is an example of a draft implement showing the general idea of what I want to achieve:

class SceneNode
{
public:

    //...
    // constructor, destructor etc
    //...

    void render(); // will call render() for each child node
    void addChild(SceneNode* child);

private:

    SceneNode* parent;
    std::vector<SceneNode*> children;

    //...
    // other members such as model data, transformation matrix etc
}

The above is certainly not set in stone, I'm very welcome to suggestions, it was purely for demonstration. It would also be useful to me to know if any suggested implementation requires additional care like a specialized copy constructor or destructor for example.

I'm assuming I will need to use the new keyword to generate the pointers, and potentially smart pointers if possible, but I am a beginner in C++ style memory management, so any help would be greatly appreciated.

Answer 1

Pointers are a good way to achieve what you're trying to do. I think what you have is exactly what you need to start.

Just because you are using pointers does not mean you need to dynamically create SceneNode's with "new" (though that is the easiest way to get started). You could use a pool of nodes, or create pointers off of statically allocated nodes.

What I like to do is create two functions - something along the lines of:

SceneNode * Alloc_SceneNode();
void Dealloc_SceneNode(SceneNode *node);

Or they can be called CreateNode() and DestroyNode(), whatever terminology you want. Use those functions to get new nodes and return nodes when you're done. Behind the scenes, they can call "new" and "delete", but in the future if you'd like to switch to a pool of nodes (which I recommend for game development) it's easy to just edit those two functions and boom. Your entire SceneGraph is no longer dynamically allocating, it's using whatever memory management pattern you want.

Oh yeah, and if you use new, make sure to delete the nodes when you're done. The simplest way to do that for a hierarchital structure like a tree is to (in the destructor of SceneNode) call delete on all of your children.