instancelib.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_INSTANCELIB_H)
#define INCLUDED_INSTANCELIB_H

#include "debugging/debugging.h"

#include "iscenegraph.h"

#include "scenelib.h"
#include "generic/reference.h"
#include "generic/callback.h"
#include <map>

class InstanceSubgraphWalker: public scene::Traversable::Walker
{
        scene::Instantiable::Observer* m_observer;
        mutable scene::Path m_path;
        mutable Stack<scene::Instance*> m_parent;
    public:
        InstanceSubgraphWalker (scene::Instantiable::Observer* observer, const scene::Path& path,
                scene::Instance* parent) :
            m_observer(observer), m_path(path), m_parent(parent)
        {
        }
        ~InstanceSubgraphWalker ()
        {
        }
        bool pre (scene::Node& node) const
        {
            m_path.push(makeReference(node));
            scene::Instance* instance = Node_getInstantiable(node)->create(m_path, m_parent.top());
            m_observer->insert(instance);
            Node_getInstantiable(node)->insert(m_observer, m_path, instance);
            m_parent.push(instance);
            return true;
        }
        void post (scene::Node& node) const
        {
            m_path.pop();
            m_parent.pop();
        }
};

class UninstanceSubgraphWalker: public scene::Traversable::Walker
{
        scene::Instantiable::Observer* m_observer;
        mutable scene::Path m_path;
    public:
        UninstanceSubgraphWalker (scene::Instantiable::Observer* observer, const scene::Path& parent) :
            m_observer(observer), m_path(parent)
        {
        }
        ~UninstanceSubgraphWalker ()
        {
        }
        bool pre (scene::Node& node) const
        {
            m_path.push(makeReference(node));
            return true;
        }
        void post (scene::Node& node) const
        {
            scene::Instance* instance = Node_getInstantiable(node)->erase(m_observer, m_path);
            m_observer->erase(instance);
            delete instance;
            m_path.pop();
        }
};

class InstanceSet: public scene::Traversable::Observer
{
        typedef std::pair<scene::Instantiable::Observer*, PathConstReference> CachePath;

        typedef CachePath key_type;

        typedef std::map<key_type, scene::Instance*> InstanceMap;
        InstanceMap m_instances;
    public:

        typedef InstanceMap::iterator iterator;

        ~InstanceSet ()
        {
        }
        iterator begin ()
        {
            return m_instances.begin();
        }
        iterator end ()
        {
            return m_instances.end();
        }

        // traverse observer
        void insert (scene::Node& child)
        {
            for (iterator i = begin(); i != end(); ++i) {
                Node_traverseSubgraph(child, InstanceSubgraphWalker((*i).first.first, (*i).first.second, (*i).second));
                (*i).second->boundsChanged();
            }
        }
        void erase (scene::Node& child)
        {
            for (iterator i = begin(); i != end(); ++i) {
                Node_traverseSubgraph(child, UninstanceSubgraphWalker((*i).first.first, (*i).first.second));
                (*i).second->boundsChanged();
            }
        }

        // instance
        void forEachInstance (const scene::Instantiable::Visitor& visitor)
        {
            for (iterator i = begin(); i != end(); ++i) {
                visitor.visit(*(*i).second);
            }
        }

        void insert (scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
        {
            ASSERT_MESSAGE(m_instances.find(key_type(observer, PathConstReference(instance->path()))) == m_instances.end(), "InstanceSet::insert - element already exists");
            m_instances.insert(InstanceMap::value_type(key_type(observer, PathConstReference(instance->path())),
                    instance));
        }
        scene::Instance* erase (scene::Instantiable::Observer* observer, const scene::Path& path)
        {
            ASSERT_MESSAGE(m_instances.find(key_type(observer, PathConstReference(path))) != m_instances.end(), "InstanceSet::erase - failed to find element");
            InstanceMap::iterator i = m_instances.find(key_type(observer, PathConstReference(path)));
            scene::Instance* instance = i->second;
            m_instances.erase(i);
            return instance;
        }

        void transformChanged ()
        {
            for (InstanceMap::iterator i = m_instances.begin(); i != m_instances.end(); ++i) {
                (*i).second->transformChanged();
            }
        }
        typedef MemberCaller<InstanceSet, &InstanceSet::transformChanged> TransformChangedCaller;
        void boundsChanged ()
        {
            for (InstanceMap::iterator i = m_instances.begin(); i != m_instances.end(); ++i) {
                (*i).second->boundsChanged();
            }
        }
        typedef MemberCaller<InstanceSet, &InstanceSet::boundsChanged> BoundsChangedCaller;
};

template<typename Functor>
inline void InstanceSet_forEach (InstanceSet& instances, const Functor& functor)
{
    for (InstanceSet::iterator i = instances.begin(), end = instances.end(); i != end; ++i) {
        functor(*(*i).second);
    }
}

template<typename Type>
class InstanceEvaluateTransform
{
    public:
        inline
        void operator() (scene::Instance& instance) const
        {
            InstanceTypeCast<Type>::cast(instance)->evaluateTransform();
        }
};

template<typename Type>
class InstanceSetEvaluateTransform
{
    public:
        static void apply (InstanceSet& instances)
        {
            InstanceSet_forEach(instances, InstanceEvaluateTransform<Type> ());
        }
        typedef ReferenceCaller<InstanceSet, &InstanceSetEvaluateTransform<Type>::apply> Caller;
};

#endif