scenelib.h

Go to the documentation of this file.

/*
 Copyright (C) 2001-2006, William Joseph.
 All Rights Reserved.

 This file is part of GtkRadiant.

 GtkRadiant is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 GtkRadiant is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with GtkRadiant; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined (INCLUDED_SCENELIB_H)
#define INCLUDED_SCENELIB_H

#include "Bounded.h"
#include "iscenegraph.h"
#include "iselection.h"

#include <cstddef>
#include <string.h>

#include "math/aabb.h"
#include "transformlib.h"
#include "generic/callback.h"
#include "generic/reference.h"
#include "container/stack.h"
#include "typesystem.h"

class Selector;
class SelectionTest;
class VolumeTest;
template<typename Element> class BasicVector3;
typedef BasicVector3<float> Vector3;
template<typename Element> class BasicVector4;
typedef BasicVector4<float> Vector4;
class Matrix4;
typedef Vector4 Quaternion;
class AABB;

class ComponentSelectionTestable
{
    public:
        STRING_CONSTANT(Name, "ComponentSelectionTestable");

        virtual ~ComponentSelectionTestable ()
        {
        }

        virtual bool isSelectedComponents () const = 0;
        virtual void setSelectedComponents (bool select, SelectionSystem::EComponentMode mode) = 0;
        virtual void testSelectComponents (Selector& selector, SelectionTest& test,
                SelectionSystem::EComponentMode mode) = 0;
};

class ComponentEditable
{
    public:
        STRING_CONSTANT(Name, "ComponentEditable");

        virtual ~ComponentEditable ()
        {
        }
        virtual const AABB& getSelectedComponentsBounds () const = 0;
};

class ComponentSnappable
{
    public:
        STRING_CONSTANT(Name, "ComponentSnappable");

        virtual ~ComponentSnappable ()
        {
        }
        virtual void snapComponents (float snap) = 0;
};

typedef TypeCastTable<NODETYPEID_MAX> NodeTypeCastTable;

template<typename Type>
class NodeType: public StaticTypeSystemInitialiser
{
        TypeId m_typeId;
    public:
        typedef typename Type::Name Name;
        NodeType () :
            m_typeId(NODETYPEID_NONE)
        {
            StaticTypeSystemInitialiser::instance().addInitialiser(InitialiseCaller(*this));
        }
        void initialise ()
        {
            m_typeId = GlobalSceneGraph().getNodeTypeId(Name());
        }
        typedef MemberCaller<NodeType<Type> , &NodeType<Type>::initialise> InitialiseCaller;
        TypeId getTypeId ()
        {
#if defined(DEBUG)
            ASSERT_MESSAGE(m_typeId != NODETYPEID_NONE, "node-type " << makeQuoted(Name()) << " used before being initialised");
#endif
            return m_typeId;
        }
};

template<typename Type>
class StaticNodeType
{
    public:
        enum unnamed0
        {
            SIZE = NODETYPEID_MAX
        };
        static TypeId getTypeId ()
        {
            return Static<NodeType<Type> >::instance().getTypeId();
        }
};

template<typename Type, typename Contained>
class NodeContainedCast: public CastInstaller<StaticNodeType<Contained> , ContainedCast<Type, Contained> >
{
};

template<typename Type>
class NodeIdentityCast: public CastInstaller<StaticNodeType<Type> , IdentityCast<Type> >
{
};

namespace scene
{
    class Node
    {
        public:
            enum unnamed0
            {
                eVisible = 0
            };
            enum unnamed1
            {
                eHidden = 1 << 0
            };
            enum unnamed2
            {
                eFiltered = 1 << 1
            };
            enum unnamed3
            {
                eExcluded = 1 << 2
            };

        private:
            unsigned int m_state;
            std::size_t m_refcount;
            void* m_node;
            NodeTypeCastTable& m_casts;

        public:
            bool m_isRoot;

            bool isRoot ()
            {
                return m_isRoot;
            }

            Node (void* node, NodeTypeCastTable& casts) :
                m_state(eVisible), m_refcount(0), m_node(node), m_casts(casts), m_isRoot(false)
            {
            }

            virtual ~Node ()
            {
            }

            virtual void release ()
            {
                // Default implementation: remove this node
                delete this;
            }

            void IncRef ()
            {
                ASSERT_MESSAGE(m_refcount < (1 << 24), "Node::decref: uninitialised refcount");
                ++m_refcount;
            }
            void DecRef ()
            {
                ASSERT_MESSAGE(m_refcount < (1 << 24), "Node::decref: uninitialised refcount");
                if (--m_refcount == 0) {
                    release();
                }
            }
            std::size_t getReferenceCount () const
            {
                return m_refcount;
            }

            void* cast (TypeId typeId) const
            {
                return m_casts.cast(typeId, m_node);
            }

            void enable (unsigned int state)
            {
                m_state |= state;
            }
            void disable (unsigned int state)
            {
                m_state &= ~state;
            }
            bool visible ()
            {
                return m_state == eVisible;
            }
            bool excluded ()
            {
                return (m_state & eExcluded) != 0;
            }
    };

    class NullNode: public Node
    {
            NodeTypeCastTable m_casts;
        public:
            NullNode () :
                scene::Node(NULL, m_casts)
            {
            }

            scene::Node& node ()
            {
                return *this;
            }
    };
}

template<typename Type>
class NodeTypeCast
{
    public:
        static Type* cast (scene::Node& node)
        {
            return static_cast<Type*> (node.cast(StaticNodeType<Type>::getTypeId()));
        }
        static const Type* cast (const scene::Node& node)
        {
            return static_cast<const Type*> (node.cast(StaticNodeType<Type>::getTypeId()));
        }
};

inline scene::Instantiable* Node_getInstantiable (scene::Node& node)
{
    return dynamic_cast<scene::Instantiable*>(&node);
}

inline scene::Traversable* Node_getTraversable (scene::Node& node)
{
    return NodeTypeCast<scene::Traversable>::cast(node);
}

inline void Node_traverseSubgraph (scene::Node& node, const scene::Traversable::Walker& walker)
{
    if (walker.pre(node)) {
        scene::Traversable* traversable = Node_getTraversable(node);
        if (traversable != 0) {
            traversable->traverse(walker);
        }
    }
    walker.post(node);
}

inline TransformNode* Node_getTransformNode (scene::Node& node)
{
    return NodeTypeCast<TransformNode>::cast(node);
}

inline bool operator< (scene::Node& node, scene::Node& other)
{
    return &node < &other;
}
inline bool operator== (scene::Node& node, scene::Node& other)
{
    return &node == &other;
}
inline bool operator!= (scene::Node& node, scene::Node& other)
{
    return !::operator==(node, other);
}

inline scene::Node& NewNullNode ()
{
    return (new scene::NullNode)->node();
}

inline void Path_deleteTop (const scene::Path& path)
{
    Node_getTraversable(path.parent())->erase(path.top());
}

class delete_all: public scene::Traversable::Walker
{
        scene::Node& m_parent;
    public:
        delete_all (scene::Node& parent) :
            m_parent(parent)
        {
        }
        bool pre (scene::Node& node) const
        {
            return false;
        }
        void post (scene::Node& node) const
        {
            Node_getTraversable(m_parent)->erase(node);
        }
};

inline void DeleteSubgraph (scene::Node& subgraph)
{
    Node_getTraversable(subgraph)->traverse(delete_all(subgraph));
}

class EntityUndefined
{
    public:
        STRING_CONSTANT(Name, "Entity");
};

inline bool Node_isEntity (scene::Node& node)
{
    return NodeTypeCast<EntityUndefined>::cast(node) != 0;
}

template<typename Functor>
class EntityWalker: public scene::Graph::Walker
{
        const Functor& functor;
    public:
        EntityWalker (const Functor& functor) :
            functor(functor)
        {
        }
        bool pre (const scene::Path& path, scene::Instance& instance) const
        {
            if (Node_isEntity(path.top())) {
                functor(instance);
                return false;
            }
            return true;
        }
};

template<typename Functor>
inline const Functor& Scene_forEachEntity (const Functor& functor)
{
    GlobalSceneGraph().traverse(EntityWalker<Functor> (functor));
    return functor;
}

class BrushUndefined
{
    public:
        STRING_CONSTANT(Name, "Brush");
};

inline bool Node_isBrush (scene::Node& node)
{
    return NodeTypeCast<BrushUndefined>::cast(node) != 0;
}

inline bool Node_isPrimitive (scene::Node& node)
{
    return Node_isBrush(node);
}

class ParentBrushes: public scene::Traversable::Walker
{
        scene::Node& m_parent;
    public:
        ParentBrushes (scene::Node& parent) :
            m_parent(parent)
        {
        }
        bool pre (scene::Node& node) const
        {
            return false;
        }
        void post (scene::Node& node) const
        {
            if (Node_isPrimitive(node)) {
                Node_getTraversable(m_parent)->insert(node);
            }
        }
};

inline void parentBrushes (scene::Node& subgraph, scene::Node& parent)
{
    Node_getTraversable(subgraph)->traverse(ParentBrushes(parent));
}

class HasBrushes: public scene::Traversable::Walker
{
        bool& m_hasBrushes;
    public:
        HasBrushes (bool& hasBrushes) :
            m_hasBrushes(hasBrushes)
        {
            m_hasBrushes = true;
        }
        bool pre (scene::Node& node) const
        {
            if (!Node_isPrimitive(node)) {
                m_hasBrushes = false;
            }
            return false;
        }
};

inline bool node_is_group (scene::Node& node)
{
    scene::Traversable* traversable = Node_getTraversable(node);
    if (traversable != 0) {
        bool hasBrushes = false;
        traversable->traverse(HasBrushes(hasBrushes));
        return hasBrushes;
    }
    return false;
}

typedef TypeCastTable<INSTANCETYPEID_MAX> InstanceTypeCastTable;

template<typename Type>
class InstanceType: public StaticTypeSystemInitialiser
{
        TypeId m_typeId;
    public:
        typedef typename Type::Name Name;
        InstanceType () :
            m_typeId(INSTANCETYPEID_NONE)
        {
            StaticTypeSystemInitialiser::instance().addInitialiser(InitialiseCaller(*this));
        }
        void initialise ()
        {
            m_typeId = GlobalSceneGraph().getInstanceTypeId(Name());
        }
        typedef MemberCaller<InstanceType<Type> , &InstanceType<Type>::initialise> InitialiseCaller;
        TypeId getTypeId ()
        {
#if defined(DEBUG)
            ASSERT_MESSAGE(m_typeId != INSTANCETYPEID_NONE, "instance-type " << makeQuoted(Name()) << " used before being initialised");
#endif
            return m_typeId;
        }
};

template<typename Type>
class StaticInstanceType
{
    public:
        enum unnamed0
        {
            SIZE = INSTANCETYPEID_MAX
        };
        static TypeId getTypeId ()
        {
            return Static<InstanceType<Type> >::instance().getTypeId();
        }
};

template<typename Type, typename Base>
class InstanceStaticCast: public CastInstaller<StaticInstanceType<Base> , StaticCast<Type, Base> >
{
};

template<typename Type, typename Contained>
class InstanceContainedCast: public CastInstaller<StaticInstanceType<Contained> , ContainedCast<Type, Contained> >
{
};

template<typename Type>
class InstanceIdentityCast: public CastInstaller<StaticInstanceType<Type> , IdentityCast<Type> >
{
};

inline Selectable* Instance_getSelectable (scene::Instance& instance);
inline const Selectable* Instance_getSelectable (const scene::Instance& instance);

inline Bounded* Instance_getBounded (scene::Instance& instance);
inline const Bounded* Instance_getBounded (const scene::Instance& instance);

namespace scene
{
    class Instance
    {
            class AABBAccumulateWalker: public scene::Graph::Walker
            {
                    AABB& m_aabb;
                    mutable std::size_t m_depth;
                public:
                    AABBAccumulateWalker (AABB& aabb) :
                        m_aabb(aabb), m_depth(0)
                    {
                    }
                    bool pre (const scene::Path& path, scene::Instance& instance) const
                    {
                        if (m_depth == 1) {
                            m_aabb.includeAABB(instance.worldAABB());
                        }
                        return ++m_depth != 2;
                    }
                    void post (const scene::Path& path, scene::Instance& instance) const
                    {
                        --m_depth;
                    }
            };

            class TransformChangedWalker: public scene::Graph::Walker
            {
                public:
                    bool pre (const scene::Path& path, scene::Instance& instance) const
                    {
                        instance.transformChangedLocal();
                        return true;
                    }
            };

            class ParentSelectedChangedWalker: public scene::Graph::Walker
            {
                public:
                    bool pre (const scene::Path& path, scene::Instance& instance) const
                    {
                        instance.parentSelectedChanged();
                        return true;
                    }
            };

            class ChildSelectedWalker: public scene::Graph::Walker
            {
                    bool& m_childSelected;
                    mutable std::size_t m_depth;
                public:
                    ChildSelectedWalker (bool& childSelected) :
                        m_childSelected(childSelected), m_depth(0)
                    {
                        m_childSelected = false;
                    }
                    bool pre (const scene::Path& path, scene::Instance& instance) const
                    {
                        if (m_depth == 1 && !m_childSelected) {
                            m_childSelected = instance.isSelected() || instance.childSelected();
                        }
                        return ++m_depth != 2;
                    }
                    void post (const scene::Path& path, scene::Instance& instance) const
                    {
                        --m_depth;
                    }
            };

            Path m_path;
            Instance* m_parent;
            void* m_instance;
            InstanceTypeCastTable& m_casts;

            mutable Matrix4 m_local2world;
            mutable AABB m_bounds;
            mutable AABB m_childBounds;
            mutable bool m_transformChanged;
            mutable bool m_transformMutex;
            mutable bool m_boundsChanged;
            mutable bool m_boundsMutex;
            mutable bool m_childBoundsChanged;
            mutable bool m_childBoundsMutex;
            mutable bool m_isSelected;
            mutable bool m_isSelectedChanged;
            mutable bool m_childSelected;
            mutable bool m_childSelectedChanged;
            mutable bool m_parentSelected;
            mutable bool m_parentSelectedChanged;
            Callback m_childSelectedChangedCallback;
            Callback m_transformChangedCallback;

            void evaluateTransform () const
            {
                if (m_transformChanged) {
                    ASSERT_MESSAGE(!m_transformMutex, "re-entering transform evaluation");
                    m_transformMutex = true;

                    m_local2world = (m_parent != 0) ? m_parent->localToWorld() : g_matrix4_identity;
                    TransformNode* transformNode = Node_getTransformNode(m_path.top());
                    if (transformNode != 0) {
                        matrix4_multiply_by_matrix4(m_local2world, transformNode->localToParent());
                    }

                    m_transformMutex = false;
                    m_transformChanged = false;
                }
            }
            void evaluateChildBounds () const
            {
                if (m_childBoundsChanged) {
                    ASSERT_MESSAGE(!m_childBoundsMutex, "re-entering bounds evaluation");
                    m_childBoundsMutex = true;

                    m_childBounds = AABB();

                    GlobalSceneGraph().traverse_subgraph(AABBAccumulateWalker(m_childBounds), m_path);

                    m_childBoundsMutex = false;
                    m_childBoundsChanged = false;
                }
            }
            void evaluateBounds () const
            {
                if (m_boundsChanged) {
                    ASSERT_MESSAGE(!m_boundsMutex, "re-entering bounds evaluation");
                    m_boundsMutex = true;

                    m_bounds = childBounds();

                    const Bounded* bounded = Instance_getBounded(*this);
                    if (bounded != 0) {
                        m_bounds.includeAABB(aabb_for_oriented_aabb_safe(bounded->localAABB(), localToWorld()));
                    }

                    m_boundsMutex = false;
                    m_boundsChanged = false;
                }
            }

            Instance (const scene::Instance& other);
            Instance& operator= (const scene::Instance& other);
        public:

            Instance (const scene::Path& path, Instance* parent, void* instance, InstanceTypeCastTable& casts) :
                m_path(path), m_parent(parent), m_instance(instance), m_casts(casts),
                        m_local2world(g_matrix4_identity), m_transformChanged(true), m_transformMutex(false),
                        m_boundsChanged(true), m_boundsMutex(false), m_childBoundsChanged(true), m_childBoundsMutex(
                                false), m_isSelectedChanged(true), m_childSelectedChanged(true),
                        m_parentSelectedChanged(true)
            {
                ASSERT_MESSAGE((parent == 0) == (path.size() == 1), "instance has invalid parent");
            }
            virtual ~Instance ()
            {
            }

            const scene::Path& path () const
            {
                return m_path;
            }

            void* cast (TypeId typeId) const
            {
                return m_casts.cast(typeId, m_instance);
            }

            const Matrix4& localToWorld () const
            {
                evaluateTransform();
                return m_local2world;
            }
            void transformChangedLocal ()
            {
                ASSERT_NOTNULL(m_parent);
                m_transformChanged = true;
                m_boundsChanged = true;
                m_childBoundsChanged = true;
                m_transformChangedCallback();
            }
            void transformChanged ()
            {
                GlobalSceneGraph().traverse_subgraph(TransformChangedWalker(), m_path);
                boundsChanged();
            }
            void setTransformChangedCallback (const Callback& callback)
            {
                m_transformChangedCallback = callback;
            }

            const AABB& worldAABB () const
            {
                evaluateBounds();
                return m_bounds;
            }
            const AABB& childBounds () const
            {
                evaluateChildBounds();
                return m_childBounds;
            }
            void boundsChanged ()
            {
                m_boundsChanged = true;
                m_childBoundsChanged = true;
                if (m_parent != 0) {
                    m_parent->boundsChanged();
                }
                GlobalSceneGraph().boundsChanged();
            }

            void childSelectedChanged ()
            {
                m_childSelectedChanged = true;
                m_childSelectedChangedCallback();
                if (m_parent != 0) {
                    m_parent->childSelectedChanged();
                }
            }
            bool childSelected () const
            {
                if (m_childSelectedChanged) {
                    m_childSelectedChanged = false;
                    GlobalSceneGraph().traverse_subgraph(ChildSelectedWalker(m_childSelected), m_path);
                }
                return m_childSelected;
            }

            void setChildSelectedChangedCallback (const Callback& callback)
            {
                m_childSelectedChangedCallback = callback;
            }
            void selectedChanged ()
            {
                m_isSelectedChanged = true;
                if (m_parent != 0) {
                    m_parent->childSelectedChanged();
                }
                GlobalSceneGraph().traverse_subgraph(ParentSelectedChangedWalker(), m_path);
            }
            bool isSelected () const
            {
                if (m_isSelectedChanged) {
                    m_isSelectedChanged = false;
                    const Selectable* selectable = Instance_getSelectable(*this);
                    m_isSelected = selectable != 0 && selectable->isSelected();
                }
                return m_isSelected;
            }

            void parentSelectedChanged ()
            {
                m_parentSelectedChanged = true;
            }
            bool parentSelected () const
            {
                if (m_parentSelectedChanged) {
                    m_parentSelectedChanged = false;
                    m_parentSelected = m_parent != 0 && (m_parent->isSelected() || m_parent->parentSelected());
                }
                return m_parentSelected;
            }
    };
}

template<typename Type>
class InstanceTypeCast
{
    public:
        static Type* cast (scene::Instance& instance)
        {
            return static_cast<Type*> (instance.cast(StaticInstanceType<Type>::getTypeId()));
        }
        static const Type* cast (const scene::Instance& instance)
        {
            return static_cast<const Type*> (instance.cast(StaticInstanceType<Type>::getTypeId()));
        }
};

template<typename Functor>
class InstanceWalker: public scene::Graph::Walker
{
        const Functor& m_functor;
    public:
        InstanceWalker (const Functor& functor) :
            m_functor(functor)
        {
        }
        bool pre (const scene::Path& path, scene::Instance& instance) const
        {
            m_functor(instance);
            return true;
        }
};

template<typename Functor>
class ChildInstanceWalker: public scene::Graph::Walker
{
        const Functor& m_functor;
        mutable std::size_t m_depth;
    public:
        ChildInstanceWalker (const Functor& functor) :
            m_functor(functor), m_depth(0)
        {
        }
        bool pre (const scene::Path& path, scene::Instance& instance) const
        {
            if (m_depth == 1) {
                m_functor(instance);
            }
            return ++m_depth != 2;
        }
        void post (const scene::Path& path, scene::Instance& instance) const
        {
            --m_depth;
        }
};

template<typename Type, typename Functor>
class InstanceApply: public Functor
{
    public:
        InstanceApply (const Functor& functor) :
            Functor(functor)
        {
        }
        void operator() (scene::Instance& instance) const
        {
            Type* result = InstanceTypeCast<Type>::cast(instance);
            if (result != 0) {
                Functor::operator()(*result);
            }
        }
};

inline Selectable* Instance_getSelectable (scene::Instance& instance)
{
    return InstanceTypeCast<Selectable>::cast(instance);
}
inline const Selectable* Instance_getSelectable (const scene::Instance& instance)
{
    return InstanceTypeCast<Selectable>::cast(instance);
}

template<typename Functor>
inline void Scene_forEachChildSelectable (const Functor& functor, const scene::Path& path)
{
    GlobalSceneGraph().traverse_subgraph(ChildInstanceWalker<InstanceApply<Selectable, Functor> > (functor), path);
}

class SelectableSetSelected
{
        bool m_selected;
    public:
        SelectableSetSelected (bool selected) :
            m_selected(selected)
        {
        }
        void operator() (Selectable& selectable) const
        {
            selectable.setSelected(m_selected);
        }
};

inline Bounded* Instance_getBounded (scene::Instance& instance)
{
    return InstanceTypeCast<Bounded>::cast(instance);
}
inline const Bounded* Instance_getBounded (const scene::Instance& instance)
{
    return InstanceTypeCast<Bounded>::cast(instance);
}

inline Transformable* Instance_getTransformable (scene::Instance& instance)
{
    return InstanceTypeCast<Transformable>::cast(instance);
}
inline const Transformable* Instance_getTransformable (const scene::Instance& instance)
{
    return InstanceTypeCast<Transformable>::cast(instance);
}

inline ComponentSelectionTestable* Instance_getComponentSelectionTestable (scene::Instance& instance)
{
    return InstanceTypeCast<ComponentSelectionTestable>::cast(instance);
}

inline ComponentEditable* Instance_getComponentEditable (scene::Instance& instance)
{
    return InstanceTypeCast<ComponentEditable>::cast(instance);
}

inline ComponentSnappable* Instance_getComponentSnappable (scene::Instance& instance)
{
    return InstanceTypeCast<ComponentSnappable>::cast(instance);
}

inline void Instance_setSelected (scene::Instance& instance, bool selected)
{
    Selectable* selectable = Instance_getSelectable(instance);
    if (selectable != 0) {
        selectable->setSelected(selected);
    }
}

inline bool Instance_isSelected (scene::Instance& instance)
{
    Selectable* selectable = Instance_getSelectable(instance);
    if (selectable != 0) {
        return selectable->isSelected();
    }
    return false;
}

inline scene::Instance& findInstance (const scene::Path& path)
{
    scene::Instance* instance = GlobalSceneGraph().find(path);
    ASSERT_MESSAGE(instance != 0, "findInstance: path not found in scene-graph");
    return *instance;
}

inline void selectPath (const scene::Path& path, bool selected)
{
    Instance_setSelected(findInstance(path), selected);
}

class SelectChildren: public scene::Traversable::Walker
{
        mutable scene::Path m_path;
    public:
        SelectChildren (const scene::Path& root) :
            m_path(root)
        {
        }
        ~SelectChildren ()
        {
        }
        bool pre (scene::Node& node) const
        {
            m_path.push(makeReference(node));
            selectPath(m_path, true);
            return false;
        }
        void post (scene::Node& node) const
        {
            m_path.pop();
        }
};

inline void Entity_setSelected (scene::Instance& entity, bool selected)
{
    scene::Node& node = entity.path().top();
    if (node_is_group(node)) {
        Node_getTraversable(node)->traverse(SelectChildren(entity.path()));
    } else {
        Instance_setSelected(entity, selected);
    }
}

inline bool Entity_isSelected (scene::Instance& entity)
{
    if (node_is_group(entity.path().top())) {
        return entity.childSelected();
    }
    return Instance_isSelected(entity);
}

class InstanceCounter
{
    public:
        unsigned int m_count;
        InstanceCounter () :
            m_count(0)
        {
        }
};

class Counter
{
    public:
        virtual ~Counter ()
        {
        }
        virtual void increment () = 0;
        virtual void decrement () = 0;
};

#include "generic/callback.h"

class SimpleCounter: public Counter
{
        Callback m_countChanged;
        std::size_t m_count;
    public:
        void setCountChangedCallback (const Callback& countChanged)
        {
            m_countChanged = countChanged;
        }
        void increment ()
        {
            ++m_count;
            m_countChanged();
        }
        void decrement ()
        {
            --m_count;
            m_countChanged();
        }
        std::size_t get () const
        {
            return m_count;
        }
};

template<typename Contained>
class ConstReference;
typedef ConstReference<scene::Path> PathConstReference;

#include "generic/referencecounted.h"
typedef SmartReference<scene::Node, IncRefDecRefCounter<scene::Node> > NodeSmartReference;

#endif