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