Fix MSYS2 issues
[xonotic/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         StaticTypeSystemInitialiser::instance().addInitialiser( InitialiseCaller( *this ) );
105 }
106 void initialise(){
107         m_typeId = GlobalSceneGraph().getNodeTypeId( Name() );
108 }
109 typedef MemberCaller<NodeType<Type>, &NodeType<Type>::initialise> InitialiseCaller;
110 TypeId getTypeId(){
111 #if defined( _DEBUG )
112         ASSERT_MESSAGE( m_typeId != NODETYPEID_NONE, "node-type " << makeQuoted( Name() ) << " used before being initialised" );
113 #endif
114         return m_typeId;
115 }
116 };
117
118 template<typename Type>
119 class StaticNodeType
120 {
121 public:
122 enum unnamed0 { SIZE = NODETYPEID_MAX };
123 static TypeId getTypeId(){
124         return Static< NodeType<Type> >::instance().getTypeId();
125 }
126 };
127
128 template<typename Type, typename Base>
129 class NodeStaticCast :
130         public CastInstaller<
131                 StaticNodeType<Base>,
132                 StaticCast<Type, Base>
133                 >
134 {
135 };
136
137 template<typename Type, typename Contained>
138 class NodeContainedCast :
139         public CastInstaller<
140                 StaticNodeType<Contained>,
141                 ContainedCast<Type, Contained>
142                 >
143 {
144 };
145
146 template<typename Type>
147 class NodeIdentityCast :
148         public CastInstaller<
149                 StaticNodeType<Type>,
150                 IdentityCast<Type>
151                 >
152 {
153 };
154
155 namespace scene
156 {
157 class Node
158 {
159 public:
160 enum unnamed0 { eVisible = 0 };
161 enum unnamed1 { eHidden = 1 << 0 };
162 enum unnamed2 { eFiltered = 1 << 1 };
163 enum unnamed3 { eExcluded = 1 << 2 };
164
165 class Symbiot
166 {
167 public:
168 virtual void release() = 0;
169 virtual ~Symbiot(){
170 }
171 };
172
173 private:
174 unsigned int m_state;
175 std::size_t m_refcount;
176 Symbiot* m_symbiot;
177 void* m_node;
178 NodeTypeCastTable& m_casts;
179
180 public:
181 bool m_isRoot;
182
183 bool isRoot(){
184         return m_isRoot;
185 }
186
187 Node( Symbiot* symbiot, void* node, NodeTypeCastTable& casts ) :
188         m_state( eVisible ),
189         m_refcount( 0 ),
190         m_symbiot( symbiot ),
191         m_node( node ),
192         m_casts( casts ),
193         m_isRoot( false ){
194 }
195 ~Node(){
196 }
197
198 void IncRef(){
199         ASSERT_MESSAGE( m_refcount < ( 1 << 24 ), "Node::decref: uninitialised refcount" );
200         ++m_refcount;
201 }
202 void DecRef(){
203         ASSERT_MESSAGE( m_refcount < ( 1 << 24 ), "Node::decref: uninitialised refcount" );
204         if ( --m_refcount == 0 ) {
205                 m_symbiot->release();
206         }
207 }
208 std::size_t getReferenceCount() const {
209         return m_refcount;
210 }
211
212 void* cast( TypeId typeId ) const {
213         return m_casts.cast( typeId, m_node );
214 }
215
216 void enable( unsigned int state ){
217         m_state |= state;
218 }
219 void disable( unsigned int state ){
220         m_state &= ~state;
221 }
222 bool visible(){
223         return m_state == eVisible;
224 }
225 bool excluded(){
226         return ( m_state & eExcluded ) != 0;
227 }
228 bool operator<( const scene::Node& other ){
229         return this < &other;
230 }
231 bool operator==( const scene::Node& other ){
232         return this == &other;
233 }
234 bool operator!=( const scene::Node& other ){
235         return this != &other;
236 }
237 };
238
239
240 class NullNode : public Node::Symbiot
241 {
242 NodeTypeCastTable m_casts;
243 Node m_node;
244 public:
245 NullNode() : m_node( this, 0, m_casts ){
246 }
247 void release(){
248         delete this;
249 }
250 scene::Node& node(){
251         return m_node;
252 }
253 };
254 }
255
256 template<typename Type>
257 class NodeTypeCast
258 {
259 public:
260 static Type* cast( scene::Node& node ){
261         return static_cast<Type*>( node.cast( StaticNodeType<Type>::getTypeId() ) );
262 }
263 static const Type* cast( const scene::Node& node ){
264         return static_cast<const Type*>( node.cast( StaticNodeType<Type>::getTypeId() ) );
265 }
266 };
267
268
269 inline scene::Instantiable* Node_getInstantiable( scene::Node& node ){
270         return NodeTypeCast<scene::Instantiable>::cast( node );
271 }
272
273 inline scene::Traversable* Node_getTraversable( scene::Node& node ){
274         return NodeTypeCast<scene::Traversable>::cast( node );
275 }
276
277 inline void Node_traverseSubgraph( scene::Node& node, const scene::Traversable::Walker& walker ){
278         if ( walker.pre( node ) ) {
279                 scene::Traversable* traversable = Node_getTraversable( node );
280                 if ( traversable != 0 ) {
281                         traversable->traverse( walker );
282                 }
283         }
284         walker.post( node );
285 }
286
287 inline TransformNode* Node_getTransformNode( scene::Node& node ){
288         return NodeTypeCast<TransformNode>::cast( node );
289 }
290
291
292 inline scene::Node& NewNullNode(){
293         return ( new scene::NullNode )->node();
294 }
295
296 inline void Path_deleteTop( const scene::Path& path ){
297         Node_getTraversable( path.parent() )->erase( path.top() );
298 }
299
300
301
302
303
304 class delete_all : public scene::Traversable::Walker
305 {
306 scene::Node& m_parent;
307 public:
308 delete_all( scene::Node& parent ) : m_parent( parent ){
309 }
310 bool pre( scene::Node& node ) const {
311         return false;
312 }
313 void post( scene::Node& node ) const {
314         Node_getTraversable( m_parent )->erase( node );
315 }
316 };
317
318 inline void DeleteSubgraph( scene::Node& subgraph ){
319         Node_getTraversable( subgraph )->traverse( delete_all( subgraph ) );
320 }
321
322
323 class EntityUndefined
324 {
325 public:
326 STRING_CONSTANT( Name, "Entity" );
327 };
328
329 inline bool Node_isEntity( scene::Node& node ){
330         return NodeTypeCast<EntityUndefined>::cast( node ) != 0;
331 }
332
333 template<typename Functor>
334 class EntityWalker : public scene::Graph::Walker
335 {
336 const Functor& functor;
337 public:
338 EntityWalker( const Functor& functor ) : functor( functor ){
339 }
340 bool pre( const scene::Path& path, scene::Instance& instance ) const {
341         if ( Node_isEntity( path.top() ) ) {
342                 functor( instance );
343                 return false;
344         }
345         return true;
346 }
347 };
348
349 template<typename Functor>
350 inline const Functor& Scene_forEachEntity( const Functor& functor ){
351         GlobalSceneGraph().traverse( EntityWalker<Functor>( functor ) );
352         return functor;
353 }
354
355 class BrushUndefined
356 {
357 public:
358 STRING_CONSTANT( Name, "Brush" );
359 };
360
361 inline bool Node_isBrush( scene::Node& node ){
362         return NodeTypeCast<BrushUndefined>::cast( node ) != 0;
363 }
364
365 class PatchUndefined
366 {
367 public:
368 STRING_CONSTANT( Name, "Patch" );
369 };
370
371 inline bool Node_isPatch( scene::Node& node ){
372         return NodeTypeCast<PatchUndefined>::cast( node ) != 0;
373 }
374
375 inline bool Node_isPrimitive( scene::Node& node ){
376 #if 1
377         return Node_isBrush( node ) || Node_isPatch( node );
378 #else
379         return !node.isRoot();
380 #endif
381 }
382
383 class ParentBrushes : public scene::Traversable::Walker
384 {
385 scene::Node& m_parent;
386 public:
387 ParentBrushes( scene::Node& parent )
388         : m_parent( parent ){
389 }
390 bool pre( scene::Node& node ) const {
391         return false;
392 }
393 void post( scene::Node& node ) const {
394         if ( Node_isPrimitive( node ) ) {
395                 Node_getTraversable( m_parent )->insert( node );
396         }
397 }
398 };
399
400 inline void parentBrushes( scene::Node& subgraph, scene::Node& parent ){
401         Node_getTraversable( subgraph )->traverse( ParentBrushes( parent ) );
402 }
403
404 class HasBrushes : public scene::Traversable::Walker
405 {
406 bool& m_hasBrushes;
407 public:
408 HasBrushes( bool& hasBrushes )
409         : m_hasBrushes( hasBrushes ){
410         m_hasBrushes = true;
411 }
412 bool pre( scene::Node& node ) const {
413         if ( !Node_isPrimitive( node ) ) {
414                 m_hasBrushes = false;
415         }
416         return false;
417 }
418 };
419
420 inline bool node_is_group( scene::Node& node ){
421         scene::Traversable* traversable = Node_getTraversable( node );
422         if ( traversable != 0 ) {
423                 bool hasBrushes = false;
424                 traversable->traverse( HasBrushes( hasBrushes ) );
425                 return hasBrushes;
426         }
427         return false;
428 }
429
430 typedef TypeCastTable<INSTANCETYPEID_MAX> InstanceTypeCastTable;
431
432 template<typename Type>
433 class InstanceType : public StaticTypeSystemInitialiser
434 {
435 TypeId m_typeId;
436 public:
437 typedef typename Type::Name Name;
438 InstanceType() : m_typeId( INSTANCETYPEID_NONE ){
439         StaticTypeSystemInitialiser::instance().addInitialiser( InitialiseCaller( *this ) );
440 }
441 void initialise(){
442         m_typeId = GlobalSceneGraph().getInstanceTypeId( Name() );
443 }
444 typedef MemberCaller<InstanceType<Type>, &InstanceType<Type>::initialise> InitialiseCaller;
445 TypeId getTypeId(){
446 #if defined( _DEBUG )
447         ASSERT_MESSAGE( m_typeId != INSTANCETYPEID_NONE, "instance-type " << makeQuoted( Name() ) << " used before being initialised" );
448 #endif
449         return m_typeId;
450 }
451 };
452
453 template<typename Type>
454 class StaticInstanceType
455 {
456 public:
457 enum unnamed0 { SIZE = INSTANCETYPEID_MAX };
458 static TypeId getTypeId(){
459         return Static< InstanceType<Type> >::instance().getTypeId();
460 }
461 };
462
463 template<typename Type, typename Base>
464 class InstanceStaticCast :
465         public CastInstaller<
466                 StaticInstanceType<Base>,
467                 StaticCast<Type, Base>
468                 >
469 {
470 };
471
472 template<typename Type, typename Contained>
473 class InstanceContainedCast :
474         public CastInstaller<
475                 StaticInstanceType<Contained>,
476                 ContainedCast<Type, Contained>
477                 >
478 {
479 };
480
481 template<typename Type>
482 class InstanceIdentityCast :
483         public CastInstaller<
484                 StaticInstanceType<Type>,
485                 IdentityCast<Type>
486                 >
487 {
488 };
489
490
491 inline Selectable* Instance_getSelectable( scene::Instance& instance );
492 inline const Selectable* Instance_getSelectable( const scene::Instance& instance );
493
494 inline Bounded* Instance_getBounded( scene::Instance& instance );
495 inline const Bounded* Instance_getBounded( const scene::Instance& instance );
496
497 namespace scene
498 {
499 class Instance
500 {
501 class AABBAccumulateWalker : public scene::Graph::Walker
502 {
503 AABB& m_aabb;
504 mutable std::size_t m_depth;
505 public:
506 AABBAccumulateWalker( AABB& aabb ) : m_aabb( aabb ), m_depth( 0 ){
507 }
508 bool pre( const scene::Path& path, scene::Instance& instance ) const {
509         if ( m_depth == 1 ) {
510                 aabb_extend_by_aabb_safe( m_aabb, instance.worldAABB() );
511         }
512         return ++m_depth != 2;
513 }
514 void post( const scene::Path& path, scene::Instance& instance ) const {
515         --m_depth;
516 }
517 };
518
519
520 class TransformChangedWalker : public scene::Graph::Walker
521 {
522 public:
523 bool pre( const scene::Path& path, scene::Instance& instance ) const {
524         instance.transformChangedLocal();
525         return true;
526 }
527 };
528
529 class ParentSelectedChangedWalker : public scene::Graph::Walker
530 {
531 public:
532 bool pre( const scene::Path& path, scene::Instance& instance ) const {
533         instance.parentSelectedChanged();
534         return true;
535 }
536 };
537
538 class ChildSelectedWalker : public scene::Graph::Walker
539 {
540 bool& m_childSelected;
541 mutable std::size_t m_depth;
542 public:
543 ChildSelectedWalker( bool& childSelected ) : m_childSelected( childSelected ), m_depth( 0 ){
544         m_childSelected = false;
545 }
546 bool pre( const scene::Path& path, scene::Instance& instance ) const {
547         if ( m_depth == 1 && !m_childSelected ) {
548                 m_childSelected = instance.isSelected() || instance.childSelected();
549         }
550         return ++m_depth != 2;
551 }
552 void post( const scene::Path& path, scene::Instance& instance ) const {
553         --m_depth;
554 }
555 };
556
557 Path m_path;
558 Instance* m_parent;
559 void* m_instance;
560 InstanceTypeCastTable& m_casts;
561
562 mutable Matrix4 m_local2world;
563 mutable AABB m_bounds;
564 mutable AABB m_childBounds;
565 mutable bool m_transformChanged;
566 mutable bool m_transformMutex;
567 mutable bool m_boundsChanged;
568 mutable bool m_boundsMutex;
569 mutable bool m_childBoundsChanged;
570 mutable bool m_childBoundsMutex;
571 mutable bool m_isSelected;
572 mutable bool m_isSelectedChanged;
573 mutable bool m_childSelected;
574 mutable bool m_childSelectedChanged;
575 mutable bool m_parentSelected;
576 mutable bool m_parentSelectedChanged;
577 Callback m_childSelectedChangedCallback;
578 Callback m_transformChangedCallback;
579
580
581 void evaluateTransform() const {
582         if ( m_transformChanged ) {
583                 ASSERT_MESSAGE( !m_transformMutex, "re-entering transform evaluation" );
584                 m_transformMutex = true;
585
586                 m_local2world = ( m_parent != 0 ) ? m_parent->localToWorld() : g_matrix4_identity;
587                 TransformNode* transformNode = Node_getTransformNode( m_path.top() );
588                 if ( transformNode != 0 ) {
589                         matrix4_multiply_by_matrix4( m_local2world, transformNode->localToParent() );
590                 }
591
592                 m_transformMutex = false;
593                 m_transformChanged = false;
594         }
595 }
596 void evaluateChildBounds() const {
597         if ( m_childBoundsChanged ) {
598                 ASSERT_MESSAGE( !m_childBoundsMutex, "re-entering bounds evaluation" );
599                 m_childBoundsMutex = true;
600
601                 m_childBounds = AABB();
602
603                 GlobalSceneGraph().traverse_subgraph( AABBAccumulateWalker( m_childBounds ), m_path );
604
605                 m_childBoundsMutex = false;
606                 m_childBoundsChanged = false;
607         }
608 }
609 void evaluateBounds() const {
610         if ( m_boundsChanged ) {
611                 ASSERT_MESSAGE( !m_boundsMutex, "re-entering bounds evaluation" );
612                 m_boundsMutex = true;
613
614                 m_bounds = childBounds();
615
616                 const Bounded* bounded = Instance_getBounded( *this );
617                 if ( bounded != 0 ) {
618                         aabb_extend_by_aabb_safe(
619                                 m_bounds,
620                                 aabb_for_oriented_aabb_safe( bounded->localAABB(), localToWorld() )
621                                 );
622                 }
623
624                 m_boundsMutex = false;
625                 m_boundsChanged = false;
626         }
627 }
628
629 Instance( const scene::Instance& other );
630 Instance& operator=( const scene::Instance& other );
631 public:
632
633 Instance( const scene::Path& path, Instance* parent, void* instance, InstanceTypeCastTable& casts ) :
634         m_path( path ),
635         m_parent( parent ),
636         m_instance( instance ),
637         m_casts( casts ),
638         m_local2world( g_matrix4_identity ),
639         m_transformChanged( true ),
640         m_transformMutex( false ),
641         m_boundsChanged( true ),
642         m_boundsMutex( false ),
643         m_childBoundsChanged( true ),
644         m_childBoundsMutex( false ),
645         m_isSelectedChanged( true ),
646         m_childSelectedChanged( true ),
647         m_parentSelectedChanged( true ){
648         ASSERT_MESSAGE( ( parent == 0 ) == ( path.size() == 1 ), "instance has invalid parent" );
649 }
650 virtual ~Instance(){
651 }
652
653 const scene::Path& path() const {
654         return m_path;
655 }
656
657 void* cast( TypeId typeId ) const {
658         return m_casts.cast( typeId, m_instance );
659 }
660
661 const Matrix4& localToWorld() const {
662         evaluateTransform();
663         return m_local2world;
664 }
665 void transformChangedLocal(){
666         ASSERT_NOTNULL( m_parent );
667         m_transformChanged = true;
668         m_boundsChanged = true;
669         m_childBoundsChanged = true;
670         m_transformChangedCallback();
671 }
672 void transformChanged(){
673         GlobalSceneGraph().traverse_subgraph( TransformChangedWalker(), m_path );
674         boundsChanged();
675 }
676 void setTransformChangedCallback( const Callback& callback ){
677         m_transformChangedCallback = callback;
678 }
679
680
681 const AABB& worldAABB() const {
682         evaluateBounds();
683         return m_bounds;
684 }
685 const AABB& childBounds() const {
686         evaluateChildBounds();
687         return m_childBounds;
688 }
689 void boundsChanged(){
690         m_boundsChanged = true;
691         m_childBoundsChanged = true;
692         if ( m_parent != 0 ) {
693                 m_parent->boundsChanged();
694         }
695         GlobalSceneGraph().boundsChanged();
696 }
697
698 void childSelectedChanged(){
699         m_childSelectedChanged = true;
700         m_childSelectedChangedCallback();
701         if ( m_parent != 0 ) {
702                 m_parent->childSelectedChanged();
703         }
704 }
705 bool childSelected() const {
706         if ( m_childSelectedChanged ) {
707                 m_childSelectedChanged = false;
708                 GlobalSceneGraph().traverse_subgraph( ChildSelectedWalker( m_childSelected ), m_path );
709         }
710         return m_childSelected;
711 }
712
713 void setChildSelectedChangedCallback( const Callback& callback ){
714         m_childSelectedChangedCallback = callback;
715 }
716 void selectedChanged(){
717         m_isSelectedChanged = true;
718         if ( m_parent != 0 ) {
719                 m_parent->childSelectedChanged();
720         }
721         GlobalSceneGraph().traverse_subgraph( ParentSelectedChangedWalker(), m_path );
722 }
723 bool isSelected() const {
724         if ( m_isSelectedChanged ) {
725                 m_isSelectedChanged = false;
726                 const Selectable* selectable = Instance_getSelectable( *this );
727                 m_isSelected = selectable != 0 && selectable->isSelected();
728         }
729         return m_isSelected;
730 }
731
732 void parentSelectedChanged(){
733         m_parentSelectedChanged = true;
734 }
735 bool parentSelected() const {
736         if ( m_parentSelectedChanged ) {
737                 m_parentSelectedChanged = false;
738                 m_parentSelected = m_parent != 0 && ( m_parent->isSelected() || m_parent->parentSelected() );
739         }
740         return m_parentSelected;
741 }
742 };
743 }
744
745 template<typename Type>
746 class InstanceTypeCast
747 {
748 public:
749 static Type* cast( scene::Instance& instance ){
750         return static_cast<Type*>( instance.cast( StaticInstanceType<Type>::getTypeId() ) );
751 }
752 static const Type* cast( const scene::Instance& instance ){
753         return static_cast<const Type*>( instance.cast( StaticInstanceType<Type>::getTypeId() ) );
754 }
755 };
756
757 template<typename Functor>
758 class InstanceWalker : public scene::Graph::Walker
759 {
760 const Functor& m_functor;
761 public:
762 InstanceWalker( const Functor& functor ) : m_functor( functor ){
763 }
764 bool pre( const scene::Path& path, scene::Instance& instance ) const {
765         m_functor( instance );
766         return true;
767 }
768 };
769
770 template<typename Functor>
771 class ChildInstanceWalker : public scene::Graph::Walker
772 {
773 const Functor& m_functor;
774 mutable std::size_t m_depth;
775 public:
776 ChildInstanceWalker( const Functor& functor ) : m_functor( functor ), m_depth( 0 ){
777 }
778 bool pre( const scene::Path& path, scene::Instance& instance ) const {
779         if ( m_depth == 1 ) {
780                 m_functor( instance );
781         }
782         return ++m_depth != 2;
783 }
784 void post( const scene::Path& path, scene::Instance& instance ) const {
785         --m_depth;
786 }
787 };
788
789 template<typename Type, typename Functor>
790 class InstanceApply : public Functor
791 {
792 public:
793 InstanceApply( const Functor& functor ) : Functor( functor ){
794 }
795 void operator()( scene::Instance& instance ) const {
796         Type* result = InstanceTypeCast<Type>::cast( instance );
797         if ( result != 0 ) {
798                 Functor::operator()( *result );
799         }
800 }
801 };
802
803 inline Selectable* Instance_getSelectable( scene::Instance& instance ){
804         return InstanceTypeCast<Selectable>::cast( instance );
805 }
806 inline const Selectable* Instance_getSelectable( const scene::Instance& instance ){
807         return InstanceTypeCast<Selectable>::cast( instance );
808 }
809
810 template<typename Functor>
811 inline void Scene_forEachChildSelectable( const Functor& functor, const scene::Path& path ){
812         GlobalSceneGraph().traverse_subgraph( ChildInstanceWalker< InstanceApply<Selectable, Functor> >( functor ), path );
813 }
814
815 class SelectableSetSelected
816 {
817 bool m_selected;
818 public:
819 SelectableSetSelected( bool selected ) : m_selected( selected ){
820 }
821 void operator()( Selectable& selectable ) const {
822         selectable.setSelected( m_selected );
823 }
824 };
825
826 inline Bounded* Instance_getBounded( scene::Instance& instance ){
827         return InstanceTypeCast<Bounded>::cast( instance );
828 }
829 inline const Bounded* Instance_getBounded( const scene::Instance& instance ){
830         return InstanceTypeCast<Bounded>::cast( instance );
831 }
832
833 inline Transformable* Instance_getTransformable( scene::Instance& instance ){
834         return InstanceTypeCast<Transformable>::cast( instance );
835 }
836 inline const Transformable* Instance_getTransformable( const scene::Instance& instance ){
837         return InstanceTypeCast<Transformable>::cast( instance );
838 }
839
840
841 inline ComponentSelectionTestable* Instance_getComponentSelectionTestable( scene::Instance& instance ){
842         return InstanceTypeCast<ComponentSelectionTestable>::cast( instance );
843 }
844
845 inline ComponentEditable* Instance_getComponentEditable( scene::Instance& instance ){
846         return InstanceTypeCast<ComponentEditable>::cast( instance );
847 }
848
849 inline ComponentSnappable* Instance_getComponentSnappable( scene::Instance& instance ){
850         return InstanceTypeCast<ComponentSnappable>::cast( instance );
851 }
852
853
854 inline void Instance_setSelected( scene::Instance& instance, bool selected ){
855         Selectable* selectable = Instance_getSelectable( instance );
856         if ( selectable != 0 ) {
857                 selectable->setSelected( selected );
858         }
859 }
860
861 inline bool Instance_isSelected( scene::Instance& instance ){
862         Selectable* selectable = Instance_getSelectable( instance );
863         if ( selectable != 0 ) {
864                 return selectable->isSelected();
865         }
866         return false;
867 }
868
869 inline scene::Instance& findInstance( const scene::Path& path ){
870         scene::Instance* instance = GlobalSceneGraph().find( path );
871         ASSERT_MESSAGE( instance != 0, "findInstance: path not found in scene-graph" );
872         return *instance;
873 }
874
875 inline void selectPath( const scene::Path& path, bool selected ){
876         Instance_setSelected( findInstance( path ), selected );
877 }
878
879 class SelectChildren : public scene::Traversable::Walker
880 {
881 mutable scene::Path m_path;
882 public:
883 SelectChildren( const scene::Path& root )
884         : m_path( root ){
885 }
886 bool pre( scene::Node& node ) const {
887         m_path.push( makeReference( node ) );
888         selectPath( m_path, true );
889         return false;
890 }
891 void post( scene::Node& node ) const {
892         m_path.pop();
893 }
894 };
895
896 inline void Entity_setSelected( scene::Instance& entity, bool selected ){
897         scene::Node& node = entity.path().top();
898         if ( node_is_group( node ) ) {
899                 Node_getTraversable( node )->traverse( SelectChildren( entity.path() ) );
900         }
901         else
902         {
903                 Instance_setSelected( entity, selected );
904         }
905 }
906
907 inline bool Entity_isSelected( scene::Instance& entity ){
908         if ( node_is_group( entity.path().top() ) ) {
909                 return entity.childSelected();
910         }
911         return Instance_isSelected( entity );
912 }
913
914
915
916 class InstanceCounter
917 {
918 public:
919 unsigned int m_count;
920 InstanceCounter() : m_count( 0 ){
921 }
922 };
923
924
925 class Counter
926 {
927 public:
928 virtual void increment() = 0;
929 virtual void decrement() = 0;
930 };
931
932 #include "generic/callback.h"
933
934 class SimpleCounter : public Counter
935 {
936 Callback m_countChanged;
937 std::size_t m_count;
938 public:
939 void setCountChangedCallback( const Callback& countChanged ){
940         m_countChanged = countChanged;
941 }
942 void increment(){
943         ++m_count;
944         m_countChanged();
945 }
946 void decrement(){
947         --m_count;
948         m_countChanged();
949 }
950 std::size_t get() const {
951         return m_count;
952 }
953 };
954
955
956 template<typename Contained>
957 class ConstReference;
958 typedef ConstReference<scene::Path> PathConstReference;
959
960 #include "generic/referencecounted.h"
961 typedef SmartReference<scene::Node, IncRefDecRefCounter<scene::Node> > NodeSmartReference;
962
963
964 #endif