NOW I do it right: #woxblox#
[divverent/netradiant.git] / libs / scenelib.h
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #if !defined (INCLUDED_SCENELIB_H)
23 #define INCLUDED_SCENELIB_H
24
25 #include "iscenegraph.h"
26 #include "iselection.h"
27
28 #include "warnings.h"
29 #include <cstddef>
30 #include <string.h>
31
32 #include "math/aabb.h"
33 #include "transformlib.h"
34 #include "generic/callback.h"
35 #include "generic/reference.h"
36 #include "container/stack.h"
37 #include "typesystem.h"
38
39 class Selector;
40 class SelectionTest;
41 class VolumeTest;
42 template<typename Element> class BasicVector3;
43 typedef BasicVector3<float> Vector3;
44 template<typename Element> class BasicVector4;
45 typedef BasicVector4<float> Vector4;
46 class Matrix4;
47 typedef Vector4 Quaternion;
48 class AABB;
49
50 class ComponentSelectionTestable
51 {
52 public:
53   STRING_CONSTANT(Name, "ComponentSelectionTestable");
54
55   virtual bool isSelectedComponents() const = 0;
56   virtual void setSelectedComponents(bool select, SelectionSystem::EComponentMode mode) = 0;
57   virtual void testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode) = 0;
58 };
59
60 class ComponentEditable
61 {
62 public:
63   STRING_CONSTANT(Name, "ComponentEditable");
64
65   virtual const AABB& getSelectedComponentsBounds() const = 0;
66 };
67
68 class ComponentSnappable
69 {
70 public:
71   STRING_CONSTANT(Name, "ComponentSnappable");
72
73   virtual void snapComponents(float snap) = 0;
74 };
75
76 class Bounded
77 {
78 public:
79   STRING_CONSTANT(Name, "Bounded");
80
81   virtual const AABB& localAABB() const = 0;
82 };
83
84 class BrushDoom3
85 {
86 public:
87   STRING_CONSTANT(Name, "BrushDoom3");
88
89   virtual void setDoom3GroupOrigin(const Vector3& origin) = 0;
90 };
91
92
93
94
95 typedef TypeCastTable<NODETYPEID_MAX> NodeTypeCastTable;
96
97 template<typename Type>
98 class NodeType : public StaticTypeSystemInitialiser
99 {
100   TypeId m_typeId;
101 public:
102   typedef typename Type::Name Name;
103   NodeType() : m_typeId(NODETYPEID_NONE)
104   {
105     StaticTypeSystemInitialiser::instance().addInitialiser(InitialiseCaller(*this));
106   }
107   void initialise()
108   {
109     m_typeId = GlobalSceneGraph().getNodeTypeId(Name());
110   }
111   typedef MemberCaller<NodeType<Type>, &NodeType<Type>::initialise> InitialiseCaller;
112   TypeId getTypeId()
113   {
114 #if defined(_DEBUG)
115     ASSERT_MESSAGE(m_typeId != NODETYPEID_NONE, "node-type " << makeQuoted(Name()) << " used before being initialised");
116 #endif
117     return m_typeId;
118   }
119 };
120
121 template<typename Type>
122 class StaticNodeType
123 {
124 public:
125   enum unnamed0 { SIZE = NODETYPEID_MAX };
126   static TypeId getTypeId()
127   {
128     return Static< NodeType<Type> >::instance().getTypeId();
129   }
130 };
131
132 template<typename Type, typename Base>
133 class NodeStaticCast :
134   public CastInstaller<
135     StaticNodeType<Base>,
136     StaticCast<Type, Base>
137   >
138 {
139 };
140
141 template<typename Type, typename Contained>
142 class NodeContainedCast :
143   public CastInstaller<
144     StaticNodeType<Contained>,
145     ContainedCast<Type, Contained>
146   >
147 {
148 };
149
150 template<typename Type>
151 class NodeIdentityCast :
152   public CastInstaller<
153     StaticNodeType<Type>,
154     IdentityCast<Type>
155   >
156 {
157 };
158
159 namespace scene
160 {
161   class Node
162   {
163   public:
164     enum unnamed0 { eVisible = 0 };
165     enum unnamed1 { eHidden = 1 << 0 };
166     enum unnamed2 { eFiltered = 1 << 1 };
167     enum unnamed3 { eExcluded = 1 << 2 };
168
169     class Symbiot
170     {
171     public:
172       virtual void release() = 0;
173     };
174
175   private:
176     unsigned int m_state;
177     std::size_t m_refcount;
178     Symbiot* m_symbiot;
179     void* m_node;
180     NodeTypeCastTable& m_casts;
181
182   public:
183     bool m_isRoot;
184
185     bool isRoot()
186     {
187       return m_isRoot;
188     }
189
190     Node(Symbiot* symbiot, void* node, NodeTypeCastTable& casts) :
191       m_state(eVisible),
192       m_refcount(0),
193       m_symbiot(symbiot),
194       m_node(node),
195       m_casts(casts),
196       m_isRoot(false)
197     {
198     }
199     ~Node()
200     {
201     }
202
203     void IncRef()
204     {
205       ASSERT_MESSAGE(m_refcount < (1 << 24), "Node::decref: uninitialised refcount");
206       ++m_refcount;
207     }
208     void DecRef()
209     {
210       ASSERT_MESSAGE(m_refcount < (1 << 24), "Node::decref: uninitialised refcount");
211       if(--m_refcount == 0)
212       {
213         m_symbiot->release();
214       }
215     }
216     std::size_t getReferenceCount() const
217     {
218       return m_refcount;
219     }
220
221     void* cast(TypeId typeId) const
222     {
223       return m_casts.cast(typeId, m_node);
224     }
225
226     void enable(unsigned int state)
227     {
228       m_state |= state;
229     }
230     void disable(unsigned int state)
231     {
232       m_state &= ~state;
233     }
234     bool visible()
235     {
236       return m_state == eVisible;
237     }
238     bool excluded()
239     {
240       return (m_state & eExcluded) != 0;
241     }
242   };
243
244   class NullNode : public Node::Symbiot
245   {
246     NodeTypeCastTable m_casts;
247     Node m_node;
248   public:
249     NullNode() : m_node(this, 0, m_casts)
250     {
251     }
252     void release()
253     {
254       delete this;
255     }
256     scene::Node& node()
257     {
258       return m_node;
259     }
260   };
261 }
262
263 template<typename Type>
264 class NodeTypeCast
265 {
266 public:
267   static Type* cast(scene::Node& node)
268   {
269     return static_cast<Type*>(node.cast(StaticNodeType<Type>::getTypeId()));
270   }
271   static const Type* cast(const scene::Node& node)
272   {
273     return static_cast<const Type*>(node.cast(StaticNodeType<Type>::getTypeId()));
274   }
275 };
276
277
278 inline scene::Instantiable* Node_getInstantiable(scene::Node& node)
279 {
280   return NodeTypeCast<scene::Instantiable>::cast(node);
281 }
282
283 inline scene::Traversable* Node_getTraversable(scene::Node& node)
284 {
285   return NodeTypeCast<scene::Traversable>::cast(node);
286 }
287
288 inline void Node_traverseSubgraph(scene::Node& node, const scene::Traversable::Walker& walker)
289 {
290   if(walker.pre(node))
291   {
292     scene::Traversable* traversable = Node_getTraversable(node);
293     if(traversable != 0)
294     {
295       traversable->traverse(walker);
296     }
297   }
298   walker.post(node);
299 }
300
301 inline TransformNode* Node_getTransformNode(scene::Node& node)
302 {
303   return NodeTypeCast<TransformNode>::cast(node);
304 }
305
306 inline bool operator<(scene::Node& node, scene::Node& other)
307 {
308   return &node < &other;
309 }
310 inline bool operator==(scene::Node& node, scene::Node& other)
311 {
312   return &node == &other;
313 }
314 inline bool operator!=(scene::Node& node, scene::Node& other)
315 {
316   return !::operator==(node, other);
317 }
318
319
320 inline scene::Node& NewNullNode()
321 {
322   return (new scene::NullNode)->node();
323 }
324
325 inline void Path_deleteTop(const scene::Path& path)
326 {
327   Node_getTraversable(path.parent())->erase(path.top());
328 }
329
330
331
332
333
334 class delete_all : public scene::Traversable::Walker
335 {
336   scene::Node& m_parent;
337 public:
338   delete_all(scene::Node& parent) : m_parent(parent)
339   {
340   }
341   bool pre(scene::Node& node) const
342   {
343     return false;
344   }
345   void post(scene::Node& node) const
346   {
347     Node_getTraversable(m_parent)->erase(node);
348   }
349 };
350
351 inline void DeleteSubgraph(scene::Node& subgraph)
352 {
353   Node_getTraversable(subgraph)->traverse(delete_all(subgraph));
354 }
355
356
357 class EntityUndefined
358 {
359 public:
360   STRING_CONSTANT(Name, "Entity");
361 };
362
363 inline bool Node_isEntity(scene::Node& node)
364 {
365   return NodeTypeCast<EntityUndefined>::cast(node) != 0;
366 }
367
368 template<typename Functor>
369 class EntityWalker : public scene::Graph::Walker
370 {
371   const Functor& functor;
372 public:
373   EntityWalker(const Functor& functor) : functor(functor)
374   {
375   }
376   bool pre(const scene::Path& path, scene::Instance& instance) const
377   {
378     if(Node_isEntity(path.top()))
379     {
380       functor(instance);
381       return false;
382     }
383     return true;
384   }
385 };
386
387 template<typename Functor>
388 inline const Functor& Scene_forEachEntity(const Functor& functor)
389 {
390   GlobalSceneGraph().traverse(EntityWalker<Functor>(functor));
391   return functor;
392 }
393
394 class BrushUndefined
395 {
396 public:
397   STRING_CONSTANT(Name, "Brush");
398 };
399
400 inline bool Node_isBrush(scene::Node& node)
401 {
402   return NodeTypeCast<BrushUndefined>::cast(node) != 0;
403 }
404
405 class PatchUndefined
406 {
407 public:
408   STRING_CONSTANT(Name, "Patch");
409 };
410
411 inline bool Node_isPatch(scene::Node& node)
412 {
413   return NodeTypeCast<PatchUndefined>::cast(node) != 0;
414 }
415
416 inline bool Node_isPrimitive(scene::Node& node)
417 {
418 #if 1
419   return Node_isBrush(node) || Node_isPatch(node);
420 #else
421   return !node.isRoot();
422 #endif
423 }
424
425 class ParentBrushes : public scene::Traversable::Walker
426 {
427   scene::Node& m_parent;
428 public:
429   ParentBrushes(scene::Node& parent)
430     : m_parent(parent)
431   {
432   }
433   bool pre(scene::Node& node) const
434   {
435     return false;
436   }
437   void post(scene::Node& node) const
438   {
439     if(Node_isPrimitive(node))
440     {
441       Node_getTraversable(m_parent)->insert(node);
442     }
443   }
444 };
445
446 inline void parentBrushes(scene::Node& subgraph, scene::Node& parent)
447 {
448   Node_getTraversable(subgraph)->traverse(ParentBrushes(parent));
449 }
450
451 class HasBrushes : public scene::Traversable::Walker
452 {
453   bool& m_hasBrushes;
454 public:
455   HasBrushes(bool& hasBrushes)
456     : m_hasBrushes(hasBrushes)
457   {
458     m_hasBrushes = true;
459   }
460   bool pre(scene::Node& node) const
461   {
462     if(!Node_isPrimitive(node))
463     {
464       m_hasBrushes = false;
465     }
466     return false;
467   }
468 };
469
470 inline bool node_is_group(scene::Node& node)
471 {
472   scene::Traversable* traversable = Node_getTraversable(node);
473   if(traversable != 0)
474   {
475     bool hasBrushes = false;
476     traversable->traverse(HasBrushes(hasBrushes));
477     return hasBrushes;
478   }
479   return false;
480 }
481
482 typedef TypeCastTable<INSTANCETYPEID_MAX> InstanceTypeCastTable;
483
484 template<typename Type>
485 class InstanceType : public StaticTypeSystemInitialiser
486 {
487   TypeId m_typeId;
488 public:
489   typedef typename Type::Name Name;
490   InstanceType() : m_typeId(INSTANCETYPEID_NONE)
491   {
492     StaticTypeSystemInitialiser::instance().addInitialiser(InitialiseCaller(*this));
493   }
494   void initialise()
495   {
496     m_typeId = GlobalSceneGraph().getInstanceTypeId(Name());
497   }
498   typedef MemberCaller<InstanceType<Type>, &InstanceType<Type>::initialise> InitialiseCaller;
499   TypeId getTypeId()
500   {
501 #if defined(_DEBUG)
502     ASSERT_MESSAGE(m_typeId != INSTANCETYPEID_NONE, "instance-type " << makeQuoted(Name()) << " used before being initialised");
503 #endif
504     return m_typeId;
505   }
506 };
507
508 template<typename Type>
509 class StaticInstanceType
510 {
511 public:
512   enum unnamed0 { SIZE = INSTANCETYPEID_MAX };
513   static TypeId getTypeId()
514   {
515     return Static< InstanceType<Type> >::instance().getTypeId();
516   }
517 };
518
519 template<typename Type, typename Base>
520 class InstanceStaticCast :
521   public CastInstaller<
522     StaticInstanceType<Base>,
523     StaticCast<Type, Base>
524   >
525 {
526 };
527
528 template<typename Type, typename Contained>
529 class InstanceContainedCast :
530   public CastInstaller<
531     StaticInstanceType<Contained>,
532     ContainedCast<Type, Contained>
533   >
534 {
535 };
536
537 template<typename Type>
538 class InstanceIdentityCast :
539   public CastInstaller<
540     StaticInstanceType<Type>,
541     IdentityCast<Type>
542   >
543 {
544 };
545
546
547 inline Selectable* Instance_getSelectable(scene::Instance& instance);
548 inline const Selectable* Instance_getSelectable(const scene::Instance& instance);
549
550 inline Bounded* Instance_getBounded(scene::Instance& instance);
551 inline const Bounded* Instance_getBounded(const scene::Instance& instance);
552
553 namespace scene
554 {
555   class Instance
556   {
557     class AABBAccumulateWalker : public scene::Graph::Walker
558     {
559       AABB& m_aabb;
560       mutable std::size_t m_depth;
561     public:
562       AABBAccumulateWalker(AABB& aabb) : m_aabb(aabb), m_depth(0)
563       {
564       }
565       bool pre(const scene::Path& path, scene::Instance& instance) const
566       {
567         if(m_depth == 1)
568         {
569           aabb_extend_by_aabb_safe(m_aabb, instance.worldAABB());
570         }
571         return ++m_depth != 2;
572       }
573       void post(const scene::Path& path, scene::Instance& instance) const
574       {
575         --m_depth;
576       }
577     };
578
579
580     class TransformChangedWalker : public scene::Graph::Walker
581     {
582     public:
583       bool pre(const scene::Path& path, scene::Instance& instance) const
584       {
585         instance.transformChangedLocal();
586         return true;
587       }
588     };
589
590     class ParentSelectedChangedWalker : public scene::Graph::Walker
591     {
592     public:
593       bool pre(const scene::Path& path, scene::Instance& instance) const
594       {
595         instance.parentSelectedChanged();
596         return true;
597       }
598     };
599
600     class ChildSelectedWalker : public scene::Graph::Walker
601     {
602       bool& m_childSelected;
603       mutable std::size_t m_depth;
604     public:
605       ChildSelectedWalker(bool& childSelected) : m_childSelected(childSelected), m_depth(0)
606       {
607         m_childSelected = false;
608       }
609       bool pre(const scene::Path& path, scene::Instance& instance) const
610       {
611         if(m_depth == 1 && !m_childSelected)
612         {
613           m_childSelected = instance.isSelected() || instance.childSelected();
614         }
615         return ++m_depth != 2;
616       }
617       void post(const scene::Path& path, scene::Instance& instance) const
618       {
619         --m_depth;
620       }
621     };
622
623     Path m_path;
624     Instance* m_parent;
625     void* m_instance;
626     InstanceTypeCastTable& m_casts;
627
628     mutable Matrix4 m_local2world;
629     mutable AABB m_bounds;
630     mutable AABB m_childBounds;
631     mutable bool m_transformChanged;
632     mutable bool m_transformMutex;
633     mutable bool m_boundsChanged;
634     mutable bool m_boundsMutex;
635     mutable bool m_childBoundsChanged;
636     mutable bool m_childBoundsMutex;
637     mutable bool m_isSelected;
638     mutable bool m_isSelectedChanged;
639     mutable bool m_childSelected;
640     mutable bool m_childSelectedChanged;
641     mutable bool m_parentSelected;
642     mutable bool m_parentSelectedChanged;
643     Callback m_childSelectedChangedCallback;
644     Callback m_transformChangedCallback;
645
646
647     void evaluateTransform() const
648     {
649       if(m_transformChanged)
650       {
651         ASSERT_MESSAGE(!m_transformMutex, "re-entering transform evaluation");
652         m_transformMutex = true;
653
654         m_local2world = (m_parent != 0) ? m_parent->localToWorld() : g_matrix4_identity;
655         TransformNode* transformNode = Node_getTransformNode(m_path.top());
656         if(transformNode != 0)
657         {
658           matrix4_multiply_by_matrix4(m_local2world, transformNode->localToParent());
659         }
660
661         m_transformMutex = false;
662         m_transformChanged = false;
663       }
664     }
665     void evaluateChildBounds() const
666     {
667       if(m_childBoundsChanged)
668       {
669         ASSERT_MESSAGE(!m_childBoundsMutex, "re-entering bounds evaluation");
670         m_childBoundsMutex = true;
671
672         m_childBounds = AABB();
673
674         GlobalSceneGraph().traverse_subgraph(AABBAccumulateWalker(m_childBounds), m_path);
675
676         m_childBoundsMutex = false;
677         m_childBoundsChanged = false;
678       }
679     }
680     void evaluateBounds() const
681     {
682       if(m_boundsChanged)
683       {
684         ASSERT_MESSAGE(!m_boundsMutex, "re-entering bounds evaluation");
685         m_boundsMutex = true;
686
687         m_bounds = childBounds();
688
689         const Bounded* bounded = Instance_getBounded(*this);
690         if(bounded != 0)
691         {
692           aabb_extend_by_aabb_safe(
693             m_bounds,
694             aabb_for_oriented_aabb_safe(bounded->localAABB(), localToWorld())
695           );
696         }
697
698         m_boundsMutex = false;
699         m_boundsChanged = false;
700       }
701     }
702
703     Instance(const scene::Instance& other);
704     Instance& operator=(const scene::Instance& other);
705   public:
706
707     Instance(const scene::Path& path, Instance* parent, void* instance, InstanceTypeCastTable& casts) :
708       m_path(path),
709       m_parent(parent),
710       m_instance(instance),
711       m_casts(casts),
712       m_local2world(g_matrix4_identity),
713       m_transformChanged(true),
714       m_transformMutex(false),
715       m_boundsChanged(true),
716       m_boundsMutex(false),
717       m_childBoundsChanged(true),
718       m_childBoundsMutex(false),
719       m_isSelectedChanged(true),
720       m_childSelectedChanged(true),
721       m_parentSelectedChanged(true)
722     {
723       ASSERT_MESSAGE((parent == 0) == (path.size() == 1), "instance has invalid parent");
724     }
725     virtual ~Instance()
726     {
727     }
728
729     const scene::Path& path() const
730     {
731       return m_path;
732     }
733
734     void* cast(TypeId typeId) const
735     {
736       return m_casts.cast(typeId, m_instance);
737     }
738
739     const Matrix4& localToWorld() const
740     {
741       evaluateTransform();
742       return m_local2world;
743     }
744     void transformChangedLocal()
745     {
746       ASSERT_NOTNULL(m_parent);
747       m_transformChanged = true;
748       m_boundsChanged = true;
749       m_childBoundsChanged = true;
750       m_transformChangedCallback();
751     }
752     void transformChanged()
753     {
754       GlobalSceneGraph().traverse_subgraph(TransformChangedWalker(), m_path);
755       boundsChanged();
756     }
757     void setTransformChangedCallback(const Callback& callback)
758     {
759       m_transformChangedCallback = callback;
760     }
761
762
763     const AABB& worldAABB() const
764     {
765       evaluateBounds();
766       return m_bounds;
767     }
768     const AABB& childBounds() const
769     {
770       evaluateChildBounds();
771       return m_childBounds;
772     }
773     void boundsChanged()
774     {
775       m_boundsChanged = true;
776       m_childBoundsChanged = true;
777       if(m_parent != 0)
778       {
779         m_parent->boundsChanged();
780       }
781       GlobalSceneGraph().boundsChanged();
782     }
783
784     void childSelectedChanged()
785     {
786       m_childSelectedChanged = true;
787       m_childSelectedChangedCallback();
788       if(m_parent != 0)
789       {
790         m_parent->childSelectedChanged();
791       }
792     }
793     bool childSelected() const
794     {
795       if(m_childSelectedChanged)
796       {
797         m_childSelectedChanged = false;
798         GlobalSceneGraph().traverse_subgraph(ChildSelectedWalker(m_childSelected), m_path);
799       }
800       return m_childSelected;
801     }
802
803     void setChildSelectedChangedCallback(const Callback& callback)
804     {
805       m_childSelectedChangedCallback = callback;
806     }
807     void selectedChanged()
808     {
809       m_isSelectedChanged = true;
810       if(m_parent != 0)
811       {
812         m_parent->childSelectedChanged();
813       }
814       GlobalSceneGraph().traverse_subgraph(ParentSelectedChangedWalker(), m_path);
815     }
816     bool isSelected() const
817     {
818       if(m_isSelectedChanged)
819       {
820         m_isSelectedChanged = false;
821         const Selectable* selectable = Instance_getSelectable(*this);
822         m_isSelected = selectable != 0 && selectable->isSelected();
823       }
824       return m_isSelected;
825     }
826
827     void parentSelectedChanged()
828     {
829       m_parentSelectedChanged = true;
830     }
831     bool parentSelected() const
832     {
833       if(m_parentSelectedChanged)
834       {
835         m_parentSelectedChanged = false;
836         m_parentSelected = m_parent != 0 && (m_parent->isSelected() || m_parent->parentSelected());
837       }
838       return m_parentSelected;
839     }
840   };
841 }
842
843 template<typename Type>
844 class InstanceTypeCast
845 {
846 public:
847   static Type* cast(scene::Instance& instance)
848   {
849     return static_cast<Type*>(instance.cast(StaticInstanceType<Type>::getTypeId()));
850   }
851   static const Type* cast(const scene::Instance& instance)
852   {
853     return static_cast<const Type*>(instance.cast(StaticInstanceType<Type>::getTypeId()));
854   }
855 };
856
857 template<typename Functor>
858 class InstanceWalker : public scene::Graph::Walker
859 {
860   const Functor& m_functor;
861 public:
862   InstanceWalker(const Functor& functor) : m_functor(functor)
863   {
864   }
865   bool pre(const scene::Path& path, scene::Instance& instance) const
866   {
867     m_functor(instance);
868     return true;
869   }
870 };
871
872 template<typename Functor>
873 class ChildInstanceWalker : public scene::Graph::Walker
874 {
875   const Functor& m_functor;
876   mutable std::size_t m_depth;
877 public:
878   ChildInstanceWalker(const Functor& functor) : m_functor(functor), m_depth(0)
879   {
880   }
881   bool pre(const scene::Path& path, scene::Instance& instance) const
882   {
883     if(m_depth == 1)
884     {
885       m_functor(instance);
886     }
887     return ++m_depth != 2;
888   }
889   void post(const scene::Path& path, scene::Instance& instance) const
890   {
891     --m_depth;
892   }
893 };
894
895 template<typename Type, typename Functor>
896 class InstanceApply : public Functor
897 {
898 public:
899   InstanceApply(const Functor& functor) : Functor(functor)
900   {
901   }
902   void operator()(scene::Instance& instance) const
903   {
904     Type* result = InstanceTypeCast<Type>::cast(instance);
905     if(result != 0)
906     {
907       Functor::operator()(*result);
908     }
909   }
910 };
911
912 inline Selectable* Instance_getSelectable(scene::Instance& instance)
913 {
914   return InstanceTypeCast<Selectable>::cast(instance);
915 }
916 inline const Selectable* Instance_getSelectable(const scene::Instance& instance)
917 {
918   return InstanceTypeCast<Selectable>::cast(instance);
919 }
920
921 template<typename Functor>
922 inline void Scene_forEachChildSelectable(const Functor& functor, const scene::Path& path)
923 {
924   GlobalSceneGraph().traverse_subgraph(ChildInstanceWalker< InstanceApply<Selectable, Functor> >(functor), path);
925 }
926
927 class SelectableSetSelected
928 {
929   bool m_selected;
930 public:
931   SelectableSetSelected(bool selected) : m_selected(selected)
932   {
933   }
934   void operator()(Selectable& selectable) const
935   {
936     selectable.setSelected(m_selected);
937   }
938 };
939
940 inline Bounded* Instance_getBounded(scene::Instance& instance)
941 {
942   return InstanceTypeCast<Bounded>::cast(instance);
943 }
944 inline const Bounded* Instance_getBounded(const scene::Instance& instance)
945 {
946   return InstanceTypeCast<Bounded>::cast(instance);
947 }
948
949 inline Transformable* Instance_getTransformable(scene::Instance& instance)
950 {
951   return InstanceTypeCast<Transformable>::cast(instance);
952 }
953 inline const Transformable* Instance_getTransformable(const scene::Instance& instance)
954 {
955   return InstanceTypeCast<Transformable>::cast(instance);
956 }
957
958
959 inline ComponentSelectionTestable* Instance_getComponentSelectionTestable(scene::Instance& instance)
960 {
961   return InstanceTypeCast<ComponentSelectionTestable>::cast(instance);
962 }
963
964 inline ComponentEditable* Instance_getComponentEditable(scene::Instance& instance)
965 {
966   return InstanceTypeCast<ComponentEditable>::cast(instance);
967 }
968
969 inline ComponentSnappable* Instance_getComponentSnappable(scene::Instance& instance)
970 {
971   return InstanceTypeCast<ComponentSnappable>::cast(instance);
972 }
973
974
975 inline void Instance_setSelected(scene::Instance& instance, bool selected)
976 {
977   Selectable* selectable = Instance_getSelectable(instance);
978   if(selectable != 0)
979   {
980     selectable->setSelected(selected);
981   }
982 }
983
984 inline bool Instance_isSelected(scene::Instance& instance)
985 {
986   Selectable* selectable = Instance_getSelectable(instance);
987   if(selectable != 0)
988   {
989     return selectable->isSelected();
990   }
991   return false;
992 }
993
994 inline scene::Instance& findInstance(const scene::Path& path)
995 {
996   scene::Instance* instance = GlobalSceneGraph().find(path);
997   ASSERT_MESSAGE(instance != 0, "findInstance: path not found in scene-graph");
998   return *instance;
999 }
1000
1001 inline void selectPath(const scene::Path& path, bool selected)
1002 {
1003   Instance_setSelected(findInstance(path), selected);
1004 }
1005
1006 class SelectChildren : public scene::Traversable::Walker
1007 {
1008   mutable scene::Path m_path;
1009 public:
1010   SelectChildren(const scene::Path& root)
1011     : m_path(root)
1012   {
1013   }
1014   bool pre(scene::Node& node) const
1015   {
1016     m_path.push(makeReference(node));
1017     selectPath(m_path, true);
1018     return false;
1019   }
1020   void post(scene::Node& node) const
1021   {
1022     m_path.pop();
1023   }
1024 };
1025
1026 inline void Entity_setSelected(scene::Instance& entity, bool selected)
1027 {
1028   scene::Node& node = entity.path().top();
1029   if(node_is_group(node))
1030   {
1031     Node_getTraversable(node)->traverse(SelectChildren(entity.path()));
1032   }
1033   else
1034   {
1035     Instance_setSelected(entity, selected);
1036   }
1037 }
1038
1039 inline bool Entity_isSelected(scene::Instance& entity)
1040 {
1041   if(node_is_group(entity.path().top()))
1042   {
1043     return entity.childSelected();
1044   }
1045   return Instance_isSelected(entity);
1046 }
1047
1048
1049
1050 class InstanceCounter
1051 {
1052 public:
1053   unsigned int m_count;
1054   InstanceCounter() : m_count(0)
1055   {
1056   }
1057 };
1058
1059
1060 class Counter
1061 {
1062 public:
1063   virtual void increment() = 0;
1064   virtual void decrement() = 0;
1065 };
1066
1067 #include "generic/callback.h"
1068
1069 class SimpleCounter : public Counter
1070 {
1071   Callback m_countChanged;
1072   std::size_t m_count;
1073 public:
1074   void setCountChangedCallback(const Callback& countChanged)
1075   {
1076     m_countChanged = countChanged;
1077   }
1078   void increment()
1079   {
1080     ++m_count;
1081     m_countChanged();
1082   }
1083   void decrement()
1084   {
1085     --m_count;
1086     m_countChanged();
1087   }
1088   std::size_t get() const
1089   {
1090     return m_count;
1091   }
1092 };
1093
1094
1095 template<typename Contained>
1096 class ConstReference;
1097 typedef ConstReference<scene::Path> PathConstReference;
1098
1099 #include "generic/referencecounted.h"
1100 typedef SmartReference<scene::Node, IncRefDecRefCounter<scene::Node> > NodeSmartReference;
1101
1102
1103 #endif