+++ /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