initial

git-svn-id: svn://svn.icculus.org/netradiant/trunk@1 61c419a2-8eb2-4b30-bcec-8cead039b335

libs/instancelib.h

@@ -0,0 +1,193 @@
+/*
+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)
+  {
+  }
+  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)
+  {
+  }
+  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;
+
+  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