iscenegraph.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_ISCENEGRAPH_H)
#define INCLUDED_ISCENEGRAPH_H

#include <cstddef>
#include "generic/constant.h"
#include "signal/signalfwd.h"

template<typename value_type>
class Stack;
template<typename Contained>
class Reference;

namespace scene
{
    class Instance;
    const Instance* const nullInstancePointer = 0;
    inline const Instance& nullInstance ()
    {
        return *nullInstancePointer;
    }

    class Node;
    const Node* const nullNodePointer = 0;
    inline const Node& nullNode ()
    {
        return *nullNodePointer;
    }
}

typedef Reference<scene::Node> NodeReference;

typedef std::size_t TypeId;

const TypeId NODETYPEID_MAX = 64;
const TypeId NODETYPEID_NONE = NODETYPEID_MAX;

const TypeId INSTANCETYPEID_MAX = 64;
const TypeId INSTANCETYPEID_NONE = INSTANCETYPEID_MAX;

namespace scene
{
    typedef Stack<NodeReference> Path;

    class Graph
    {
        public:
            INTEGER_CONSTANT(Version, 1);
            STRING_CONSTANT(Name, "scenegraph");

            class Walker
            {
                public:
                    virtual ~Walker ()
                    {
                    }
                    virtual bool pre (const Path& path, Instance& instance) const = 0;
                    virtual void post (const Path& path, Instance& instance) const
                    {
                    }
            };

            virtual ~Graph ()
            {
            }

            virtual Node& root () = 0;
            virtual void insert_root (Node& root) = 0;
            virtual void erase_root () = 0;
            virtual void traverse (const Walker& walker) = 0;
            virtual void traverse_subgraph (const Walker& walker, const Path& start) = 0;
            virtual scene::Instance* find (const Path& path) = 0;
            virtual scene::Instance* find (Node& node) = 0;

            virtual void sceneChanged () = 0;
            virtual void addSceneChangedCallback (const SignalHandler& handler) = 0;

            virtual void boundsChanged () = 0;
            virtual SignalHandlerId addBoundsChangedCallback (const SignalHandler& boundsChanged) = 0;
            virtual void removeBoundsChangedCallback (SignalHandlerId id) = 0;

            virtual TypeId getNodeTypeId (const char* name) = 0;
            virtual TypeId getInstanceTypeId (const char* name) = 0;
    };

    class Traversable
    {
        public:
            STRING_CONSTANT(Name, "scene::Traversable");

            class Observer
            {
                public:
                    virtual ~Observer ()
                    {
                    }

                    virtual void insert (Node& node) = 0;
                    virtual void erase (Node& node) = 0;
            };

            class Walker
            {
                public:
                    virtual ~Walker ()
                    {
                    }

                    virtual bool pre (Node& node) const = 0;
                    virtual void post (Node& node) const
                    {
                    }
            };

            virtual ~Traversable ()
            {
            }

            virtual void insert (Node& node) = 0;
            virtual void erase (Node& node) = 0;
            virtual void traverse (const Walker& walker) = 0;
            virtual bool empty () const = 0;
    };

    class Instantiable
    {
        public:
            STRING_CONSTANT(Name, "scene::Instantiable");

            class Observer
            {
                public:
                    virtual ~Observer ()
                    {
                    }

                    virtual void insert (scene::Instance* instance) = 0;
                    virtual void erase (scene::Instance* instance) = 0;
            };

            class Visitor
            {
                public:
                    virtual ~Visitor ()
                    {
                    }

                    virtual void visit (Instance& instance) const = 0;
            };

            virtual ~Instantiable ()
            {
            }

            virtual scene::Instance* create (const scene::Path& path, scene::Instance* parent) = 0;
            virtual void forEachInstance (const Visitor& visitor) = 0;
            virtual void insert (Observer* observer, const Path& path, scene::Instance* instance) = 0;
            virtual scene::Instance* erase (Observer* observer, const Path& path) = 0;
    };

    class Cloneable
    {
        public:
            STRING_CONSTANT(Name, "scene::Cloneable");

            virtual ~Cloneable ()
            {
            }

            virtual scene::Node& clone () const = 0;
    };
}

#include "modulesystem.h"

template<typename Type>
class GlobalModule;
typedef GlobalModule<scene::Graph> GlobalSceneGraphModule;

template<typename Type>
class GlobalModuleRef;
typedef GlobalModuleRef<scene::Graph> GlobalSceneGraphModuleRef;

inline scene::Graph& GlobalSceneGraph ()
{
    return GlobalSceneGraphModule::getTable();
}

inline void AddSceneChangeCallback (const SignalHandler& handler)
{
    GlobalSceneGraph().addSceneChangedCallback(handler);
}
inline void SceneChangeNotify ()
{
    GlobalSceneGraph().sceneChanged();
}

#endif