Added missing bitmaps
[xonotic/netradiant.git] / plugins / entity / group.cpp
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 ///\file
23 ///\brief Represents any entity which does not have a fixed size specified in its entity-definition (except misc_model).
24 ///
25 /// This entity behaves as a group, i.e. it contains brushes.
26
27 #include "cullable.h"
28 #include "renderable.h"
29 #include "editable.h"
30
31 #include "selectionlib.h"
32 #include "instancelib.h"
33 #include "transformlib.h"
34 #include "traverselib.h"
35 #include "entitylib.h"
36 #include "render.h"
37 #include "eclasslib.h"
38
39 #include "targetable.h"
40 #include "origin.h"
41 #include "angles.h"
42 #include "scale.h"
43 #include "filters.h"
44 #include "namedentity.h"
45 #include "keyobservers.h"
46 #include "namekeys.h"
47
48 #include "entity.h"
49
50 class Group
51 {
52   EntityKeyValues m_entity;
53   KeyObserverMap m_keyObservers;
54   MatrixTransform m_transform;
55   TraversableNodeSet m_traverse;
56
57   ClassnameFilter m_filter;
58   NamedEntity m_named;
59   NameKeys m_nameKeys;
60
61   RenderableNamedEntity m_renderName;
62
63   Callback m_transformChanged;
64
65   void construct()
66   {
67     m_keyObservers.insert("classname", ClassnameFilter::ClassnameChangedCaller(m_filter));
68     m_keyObservers.insert(Static<KeyIsName>::instance().m_nameKey, NamedEntity::IdentifierChangedCaller(m_named));
69   }
70  
71 public:
72   Group(EntityClass* eclass, scene::Node& node, const Callback& transformChanged) :
73     m_entity(eclass),
74     m_filter(m_entity, node),
75     m_named(m_entity),
76     m_nameKeys(m_entity),
77     m_renderName(m_named, g_vector3_identity),
78     m_transformChanged(transformChanged)
79   {
80     construct();
81   }
82   Group(const Group& other, scene::Node& node, const Callback& transformChanged) :
83     m_entity(other.m_entity),
84     m_filter(m_entity, node),
85     m_named(m_entity),
86     m_nameKeys(m_entity),
87     m_renderName(m_named, g_vector3_identity),
88     m_transformChanged(transformChanged)
89   {
90     construct();
91   }
92
93   InstanceCounter m_instanceCounter;
94   void instanceAttach(const scene::Path& path)
95   {
96     if(++m_instanceCounter.m_count == 1)
97     {
98       m_filter.instanceAttach();
99       m_entity.instanceAttach(path_find_mapfile(path.begin(), path.end()));
100       m_traverse.instanceAttach(path_find_mapfile(path.begin(), path.end()));
101       m_entity.attach(m_keyObservers);
102     }
103   }
104   void instanceDetach(const scene::Path& path)
105   {
106     if(--m_instanceCounter.m_count == 0)
107     {
108       m_entity.detach(m_keyObservers);
109       m_traverse.instanceDetach(path_find_mapfile(path.begin(), path.end()));
110       m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
111       m_filter.instanceDetach();
112     }
113   }
114
115   EntityKeyValues& getEntity()
116   {
117     return m_entity;
118   }
119   const EntityKeyValues& getEntity() const
120   {
121     return m_entity;
122   }
123
124   scene::Traversable& getTraversable()
125   {
126     return m_traverse;
127   }
128   Namespaced& getNamespaced()
129   {
130     return m_nameKeys;
131   }
132   Nameable& getNameable()
133   {
134     return m_named;
135   }
136   TransformNode& getTransformNode()
137   {
138     return m_transform;
139   }
140
141   void attach(scene::Traversable::Observer* observer)
142   {
143     m_traverse.attach(observer);
144   }
145   void detach(scene::Traversable::Observer* observer)
146   {
147     m_traverse.detach(observer);
148   }
149
150   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
151   {
152     renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
153   }
154   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
155   {
156     renderSolid(renderer, volume, localToWorld);
157 #if 0
158     if(g_showNames)
159     {
160       renderer.addRenderable(m_renderName, g_matrix4_identity);
161     }
162 #endif
163   }
164 };
165
166 #if 0
167 class TransformableSetTranslation
168 {
169   Translation m_value;
170 public:
171   TransformableSetTranslation(const Translation& value) : m_value(value)
172   {
173   }
174   void operator()(Transformable& transformable) const
175   {
176     transformable.setTranslation(m_value);
177   }
178 };
179
180 class TransformableSetRotation
181 {
182   Rotation m_value;
183 public:
184   TransformableSetRotation(const Rotation& value) : m_value(value)
185   {
186   }
187   void operator()(Transformable& transformable) const
188   {
189     transformable.setRotation(m_value);
190   }
191 };
192
193 class TransformableSetScale
194 {
195   Scale m_value;
196 public:
197   TransformableSetScale(const Scale& value) : m_value(value)
198   {
199   }
200   void operator()(Transformable& transformable) const
201   {
202     transformable.setScale(m_value);
203   }
204 };
205
206 class TransformableSetType
207 {
208   TransformModifierType m_value;
209 public:
210   TransformableSetType(const TransformModifierType& value) : m_value(value)
211   {
212   }
213   void operator()(Transformable& transformable) const
214   {
215     transformable.setType(m_value);
216   }
217 };
218
219 class TransformableFreezeTransform
220 {
221   TransformModifierType m_value;
222 public:
223   void operator()(Transformable& transformable) const
224   {
225     transformable.freezeTransform();
226   }
227 };
228
229 template<typename Functor>
230 inline void Scene_forEachChildTransformable(const Functor& functor, const scene::Path& path)
231 {
232   GlobalSceneGraph().traverse_subgraph(ChildInstanceWalker< InstanceApply<Transformable, Functor> >(functor), path);
233 }
234 #endif
235
236 class GroupInstance :
237   public TargetableInstance,
238 #if 0
239   public Transformable,
240 #endif
241   public Renderable
242 {
243   class TypeCasts
244   {
245     InstanceTypeCastTable m_casts;
246   public:
247     TypeCasts()
248     {
249       m_casts = TargetableInstance::StaticTypeCasts::instance().get();
250       InstanceStaticCast<GroupInstance, Renderable>::install(m_casts);
251 #if 0
252       InstanceStaticCast<GroupInstance, Transformable>::install(m_casts);
253 #endif
254     }
255     InstanceTypeCastTable& get()
256     {
257       return m_casts;
258     }
259   };
260
261   Group& m_contained;
262 public:
263   typedef LazyStatic<TypeCasts> StaticTypeCasts;
264
265   GroupInstance(const scene::Path& path, scene::Instance* parent, Group& group) :
266     TargetableInstance(path, parent, this, StaticTypeCasts::instance().get(), group.getEntity(), *this),
267     m_contained(group)
268   {
269     m_contained.instanceAttach(Instance::path());
270     StaticRenderableConnectionLines::instance().attach(*this);
271   }
272   ~GroupInstance()
273   {
274     StaticRenderableConnectionLines::instance().detach(*this);
275     m_contained.instanceDetach(Instance::path());
276   }
277   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
278   {
279     m_contained.renderSolid(renderer, volume, Instance::localToWorld());
280   }
281   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
282   {
283     m_contained.renderWireframe(renderer, volume, Instance::localToWorld());
284   }
285
286 #if 0
287   void setType(TransformModifierType type)
288   {
289     Scene_forEachChildTransformable(TransformableSetType(type), Instance::path());
290   }
291   void setTranslation(const Translation& value)
292   {
293     Scene_forEachChildTransformable(TransformableSetTranslation(value), Instance::path());
294   }
295   void setRotation(const Rotation& value)
296   {
297     Scene_forEachChildTransformable(TransformableSetRotation(value), Instance::path());
298   }
299   void setScale(const Scale& value)
300   {
301     Scene_forEachChildTransformable(TransformableSetScale(value), Instance::path());
302   }
303   void freezeTransform()
304   {
305     Scene_forEachChildTransformable(TransformableFreezeTransform(), Instance::path());
306   }
307
308   void evaluateTransform()
309   {
310   }
311 #endif
312 };
313
314 class GroupNode :
315   public scene::Node::Symbiot,
316   public scene::Instantiable,
317   public scene::Cloneable,
318   public scene::Traversable::Observer
319 {
320   class TypeCasts
321   {
322     NodeTypeCastTable m_casts;
323   public:
324     TypeCasts()
325     {
326       NodeStaticCast<GroupNode, scene::Instantiable>::install(m_casts);
327       NodeStaticCast<GroupNode, scene::Cloneable>::install(m_casts);
328       NodeContainedCast<GroupNode, scene::Traversable>::install(m_casts);
329       NodeContainedCast<GroupNode, TransformNode>::install(m_casts);
330       NodeContainedCast<GroupNode, Entity>::install(m_casts);
331       NodeContainedCast<GroupNode, Nameable>::install(m_casts);
332       NodeContainedCast<GroupNode, Namespaced>::install(m_casts);
333     }
334     NodeTypeCastTable& get()
335     {
336       return m_casts;
337     }
338   };
339
340
341   scene::Node m_node;
342   InstanceSet m_instances;
343   Group m_contained;
344
345   void construct()
346   {
347     m_contained.attach(this);
348   }
349   void destroy()
350   {
351     m_contained.detach(this);
352   }
353
354 public:
355
356   typedef LazyStatic<TypeCasts> StaticTypeCasts;
357
358   scene::Traversable& get(NullType<scene::Traversable>)
359   {
360     return m_contained.getTraversable();
361   }
362   TransformNode& get(NullType<TransformNode>)
363   {
364     return m_contained.getTransformNode();
365   }
366   Entity& get(NullType<Entity>)
367   {
368     return m_contained.getEntity();
369   }
370   Nameable& get(NullType<Nameable>)
371   {
372     return m_contained.getNameable();
373   }
374   Namespaced& get(NullType<Namespaced>)
375   {
376     return m_contained.getNamespaced();
377   }
378
379   GroupNode(EntityClass* eclass) :
380     m_node(this, this, StaticTypeCasts::instance().get()),
381     m_contained(eclass, m_node, InstanceSet::TransformChangedCaller(m_instances))
382   {
383     construct();
384   }
385   GroupNode(const GroupNode& other) :
386     scene::Node::Symbiot(other),
387     scene::Instantiable(other),
388     scene::Cloneable(other),
389     scene::Traversable::Observer(other),
390     m_node(this, this, StaticTypeCasts::instance().get()),
391     m_contained(other.m_contained, m_node, InstanceSet::TransformChangedCaller(m_instances))
392   {
393     construct();
394   }
395   ~GroupNode()
396   {
397     destroy();
398   }
399
400   void release()
401   {
402     delete this;
403   }
404   scene::Node& node()
405   {
406     return m_node;
407   }
408
409   scene::Node& clone() const
410   {
411     return (new GroupNode(*this))->node();
412   }
413
414   void insert(scene::Node& child)
415   {
416     m_instances.insert(child);
417   }
418   void erase(scene::Node& child)
419   {
420     m_instances.erase(child);
421   }
422
423   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
424   {
425     return new GroupInstance(path, parent, m_contained);
426   }
427   void forEachInstance(const scene::Instantiable::Visitor& visitor)
428   {
429     m_instances.forEachInstance(visitor);
430   }
431   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
432   {
433     m_instances.insert(observer, path, instance);
434   }
435   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
436   {
437     return m_instances.erase(observer, path);
438   }
439 };
440
441 scene::Node& New_Group(EntityClass* eclass)
442 {
443   return (new GroupNode(eclass))->node();
444 }