Scene Graph Update Callback Design

Question

So Im using Open Scene graph to create an application and I have a callback class that extends from OSG's callback class. Its just a callback that is called each frame in the update event traversal of the scene graphs nodes.

I need different callback classes that do different operations on the nodes they are attached to. So I have a base callback class which I call controller base:

class ControllerBase : public osg::NodeCallback
{
public:
    ControllerBase();
private:
    // operator is overridden here from NodeCallback and is called each frame.
    virtual void operator()(osg::Node * n, osg::NodeVisitor * nv);
}

operator() gives me the node the callback is attached too and a Node Visitor. Now depending on the node it might be a different class such as a transform or a switch.

So I need to make a dynamic cast but for each possible type the node may be. So:

class ControllerBase : public osg::NodeCallback
{
public:
    ControllerBase();
private:
    virtual void operator()(osg::Node * n, osg::NodeVisitor * nv)
    {
      Type1 * t1 = dynamic_cast<Type1*>(node);
      Type2 * t2 = dynamic_cast<Type1*>(node);
      Type3 * t3 = dynamic_cast<Type1*>(node);

    }
}

Then send them out via a virtual method to be inherited by a specific controller class that I will attach to the node.

class ControllerBase : public osg::NodeCallback
{
public:
    ControllerBase();
protected:

private:

    virtual void On_Frame(Type1*, osg::NodeVisitor) = 0;
    virtual void On_Frame(Type2*, osg::NodeVisitor) = 0;
    virtual void On_Frame(Type3*, osg::NodeVisitor) = 0;

    virtual void operator()(osg::Node * n, osg::NodeVisitor * nv)
    {
      Type1 * t1 = dynamic_cast<Type1*>(node);
      Type2 * t2 = dynamic_cast<Type1*>(node);
      Type3 * t3 = dynamic_cast<Type1*>(node);

      if(t1)
        On_Frame(t1, nv);
      if(t2)
        On_Frame(t2, nv);
      if(t3)
        On_Frame(t3, nv);

    }
}

class Type1_Controller
{
    public:
        Type1_Controler();
    private:
        virtual void On_Frame(Type1 * type, osg::NodeVisitor *nv) override
        {
            // Do type 1 related stuff here. 
        }
        virtual void On_Frame(Type2 * type, osg::NodeVisitor *nv) override
        {
            // Leave empty, not needed. 
        }

        virtual void On_Frame(Type3 * type, osg::NodeVisitor *nv) override
        {
            // Leave empty, not needed. 
        }
}

So now for each type of controller i have, I have to implement the remaining empty methods. This feels like bad design, but I can't figure out how to write a better implementation. Maybe its not so bad with 3 types, but I may have more to add as I go along. I thought about using a template class, but if I'm not mistaken I can't have virtual methods in a template class. I could just use non pure virtual methods with empty implementation I suppose that could then be overriden at choice. What would a good approach be or suggested?

score 1 · Accepted Answer · answered Jan 13 '15 at 20:30

osg::NodeVisitor is more or less a textbook implementation of the Visitor Design Pattern. (see http://en.wikipedia.org/wiki/Design_Patterns for more info on the original "Gang of Four", or GoF, book).

You can override accept(NodeVisitor) in your t1 node class to try casting to your t1 visitor type, eg:

 Type1_Visitor* vis = dynamic_cast<NodeVisitor> nv;
 if(vis)
    vis->Type1Apply(*this);
 else
    nv->apply(*this);

Of course, there is a little more to it, but that is the general idea of double-dispatching as laid out in the GoF book.

score 0 · Answer 2 · answered Jan 08 '15 at 15:30

0

Based on your design it looks like the classes - Type1, Type2, Type3 all derive from osg::Node. In this case why do you want to use a dynamic_cast and try to determine the type in the operator() overload ? You can do this in ControllerBase-

virtual void operator()(osg::Node * n, osg::NodeVisitor * nv)
{
  On_Frame(n, nv);
}

Then in each of Type1_Controller, Type2_Controller and so on have a single On_Frame method as -

virtual void On_Frame(osg::Node * n, osg::NodeVisitor *nv) override
{
   Type1 * t1 = dynamic_cast<Type1*>(n);
    if(t1)
    {
       // only if t1 do something
    }
 }

answered Jan 08 '15 at 15:30

sn710

581
5
20

Your probably right. In some cases Ill have different controller classes for objects that all would use Type1 for example. I just thought it would be nice to handle dynamic casting in one place, instead of in each individual controller class. But I suppose that is what I will have to do. – Chris Shields Jan 09 '15 at 09:36
Even if multiple controller classes are attached to the same type of object, I think by appropriate handling within the On_Frame function it would still work fine :) – sn710 Jan 10 '15 at 12:02

Scene Graph Update Callback Design

2 Answers2