--- /dev/null
+/*
+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 "iscenegraph.h"
+#include "iselection.h"
+
+#include "warnings.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 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 const AABB& getSelectedComponentsBounds() const = 0;
+};
+
+class ComponentSnappable
+{
+public:
+ STRING_CONSTANT(Name, "ComponentSnappable");
+
+ virtual void snapComponents(float snap) = 0;
+};
+
+class Bounded
+{
+public:
+ STRING_CONSTANT(Name, "Bounded");
+
+ virtual const AABB& localAABB() const = 0;
+};
+
+class BrushDoom3
+{
+public:
+ STRING_CONSTANT(Name, "BrushDoom3");
+
+ virtual void setDoom3GroupOrigin(const Vector3& origin) = 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 Base>
+class NodeStaticCast :
+ public CastInstaller<
+ StaticNodeType<Base>,
+ StaticCast<Type, Base>
+ >
+{
+};
+
+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 };
+
+ class Symbiot
+ {
+ public:
+ virtual void release() = 0;
+ };
+
+ private:
+ unsigned int m_state;
+ std::size_t m_refcount;
+ Symbiot* m_symbiot;
+ void* m_node;
+ NodeTypeCastTable& m_casts;
+
+ public:
+ bool m_isRoot;
+
+ bool isRoot()
+ {
+ return m_isRoot;
+ }
+
+ Node(Symbiot* symbiot, void* node, NodeTypeCastTable& casts) :
+ m_state(eVisible),
+ m_refcount(0),
+ m_symbiot(symbiot),
+ m_node(node),
+ m_casts(casts),
+ m_isRoot(false)
+ {
+ }
+ ~Node()
+ {
+ }
+
+ 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)
+ {
+ m_symbiot->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::Symbiot
+ {
+ NodeTypeCastTable m_casts;
+ Node m_node;
+ public:
+ NullNode() : m_node(this, 0, m_casts)
+ {
+ }
+ void release()
+ {
+ delete this;
+ }
+ scene::Node& node()
+ {
+ return m_node;
+ }
+ };
+}
+
+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 NodeTypeCast<scene::Instantiable>::cast(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;
+}
+
+class PatchUndefined
+{
+public:
+ STRING_CONSTANT(Name, "Patch");
+};
+
+inline bool Node_isPatch(scene::Node& node)
+{
+ return NodeTypeCast<PatchUndefined>::cast(node) != 0;
+}
+
+inline bool Node_isPrimitive(scene::Node& node)
+{
+#if 1
+ return Node_isBrush(node) || Node_isPatch(node);
+#else
+ return !node.isRoot();
+#endif
+}
+
+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)
+ {
+ aabb_extend_by_aabb_safe(m_aabb, 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)
+ {
+ aabb_extend_by_aabb_safe(
+ m_bounds,
+ 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)
+ {
+ }
+ 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 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
projects / voretournament / voretournament.git / blobdiff