option -randomsamples: makes -samples use adaptive random subsampling (only subsample...
[divverent/netradiant.git] / plugins / entity / generic.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 has a fixed size specified in its entity-definition and does not display a model (e.g. info_player_start).
24 ///
25 /// This entity displays an axis-aligned bounding box of the size and colour specified in its entity-definition.
26 /// The "origin" key directly controls the entity's local-to-parent transform.
27 /// An arrow is drawn to visualise the "angle" key.
28
29 #include "cullable.h"
30 #include "renderable.h"
31 #include "editable.h"
32
33 #include "math/frustum.h"
34 #include "selectionlib.h"
35 #include "instancelib.h"
36 #include "transformlib.h"
37 #include "entitylib.h"
38 #include "render.h"
39 #include "eclasslib.h"
40 #include "math/line.h"
41
42 #include "targetable.h"
43 #include "origin.h"
44 #include "angles.h"
45 #include "filters.h"
46 #include "namedentity.h"
47 #include "keyobservers.h"
48 #include "namekeys.h"
49 #include "rotation.h"
50
51 #include "entity.h"
52
53
54 class RenderableArrow : public OpenGLRenderable
55 {
56   const Vector3& m_origin;
57   const Vector3& m_angles;
58
59 public:
60   RenderableArrow(const Vector3& origin, const Vector3& angles)
61     : m_origin(origin), m_angles(angles)
62   {
63   }
64
65   void render(RenderStateFlags state) const
66   {
67     Matrix4 mat = matrix4_rotation_for_euler_xyz_degrees(m_angles);
68     arrow_draw(m_origin, matrix4_transformed_direction(mat, Vector3(1, 0, 0)), matrix4_transformed_direction(mat, Vector3(0, 1, 0)), matrix4_transformed_direction(mat, Vector3(0, 0, 1)));
69   }
70 };
71
72 inline void read_aabb(AABB& aabb, const EntityClass& eclass)
73 {
74   aabb = aabb_for_minmax(eclass.mins, eclass.maxs);
75 }
76
77
78 class GenericEntity :
79   public Cullable,
80   public Bounded,
81   public Snappable
82 {
83   EntityKeyValues m_entity;
84   KeyObserverMap m_keyObservers;
85   MatrixTransform m_transform;
86
87   OriginKey m_originKey;
88   Vector3 m_origin;
89   AnglesKey m_anglesKey;
90   Vector3 m_angles;
91
92   ClassnameFilter m_filter;
93   NamedEntity m_named;
94   NameKeys m_nameKeys;
95
96   AABB m_aabb_local;
97
98   RenderableArrow m_arrow;
99   RenderableSolidAABB m_aabb_solid;
100   RenderableWireframeAABB m_aabb_wire;
101   RenderableNamedEntity m_renderName;
102
103   Callback m_transformChanged;
104   Callback m_evaluateTransform;
105
106   void construct()
107   {
108     read_aabb(m_aabb_local, m_entity.getEntityClass());
109
110     m_keyObservers.insert("classname", ClassnameFilter::ClassnameChangedCaller(m_filter));
111     m_keyObservers.insert(Static<KeyIsName>::instance().m_nameKey, NamedEntity::IdentifierChangedCaller(m_named));
112     m_keyObservers.insert("angle", AnglesKey::AngleChangedCaller(m_anglesKey));
113     m_keyObservers.insert("angles", AnglesKey::AnglesChangedCaller(m_anglesKey));
114     m_keyObservers.insert("origin", OriginKey::OriginChangedCaller(m_originKey));
115   }
116
117 // vc 2k5 compiler fix  
118 #if _MSC_VER >= 1400
119         public:
120 #endif
121
122   void updateTransform()
123   {
124     m_transform.localToParent() = g_matrix4_identity;
125     matrix4_translate_by_vec3(m_transform.localToParent(), m_origin);
126     m_transformChanged();
127   }
128   typedef MemberCaller<GenericEntity, &GenericEntity::updateTransform> UpdateTransformCaller;
129   void originChanged()
130   {
131     m_origin = m_originKey.m_origin;
132     updateTransform();
133   }
134   typedef MemberCaller<GenericEntity, &GenericEntity::originChanged> OriginChangedCaller;
135   void anglesChanged()
136   {
137     m_angles = m_anglesKey.m_angles;
138     updateTransform();
139   }
140   typedef MemberCaller<GenericEntity, &GenericEntity::anglesChanged> AnglesChangedCaller;
141 public:
142
143   GenericEntity(EntityClass* eclass, scene::Node& node, const Callback& transformChanged, const Callback& evaluateTransform) :
144     m_entity(eclass),
145     m_originKey(OriginChangedCaller(*this)),
146     m_origin(ORIGINKEY_IDENTITY),
147     m_anglesKey(AnglesChangedCaller(*this)),
148     m_angles(ANGLESKEY_IDENTITY),
149     m_filter(m_entity, node),
150     m_named(m_entity),
151     m_nameKeys(m_entity),
152     m_arrow(m_aabb_local.origin, m_angles),
153     m_aabb_solid(m_aabb_local),
154     m_aabb_wire(m_aabb_local),
155     m_renderName(m_named, g_vector3_identity),
156     m_transformChanged(transformChanged),
157     m_evaluateTransform(evaluateTransform)
158   {
159     construct();
160   }
161   GenericEntity(const GenericEntity& other, scene::Node& node, const Callback& transformChanged, const Callback& evaluateTransform) :
162     m_entity(other.m_entity),
163     m_originKey(OriginChangedCaller(*this)),
164     m_origin(ORIGINKEY_IDENTITY),
165     m_anglesKey(AnglesChangedCaller(*this)),
166     m_angles(ANGLESKEY_IDENTITY),
167     m_filter(m_entity, node),
168     m_named(m_entity),
169     m_nameKeys(m_entity),
170     m_arrow(m_aabb_local.origin, m_angles),
171     m_aabb_solid(m_aabb_local),
172     m_aabb_wire(m_aabb_local),
173     m_renderName(m_named, g_vector3_identity),
174     m_transformChanged(transformChanged),
175     m_evaluateTransform(evaluateTransform)
176   {
177     construct();
178   }
179
180   InstanceCounter m_instanceCounter;
181   void instanceAttach(const scene::Path& path)
182   {
183     if(++m_instanceCounter.m_count == 1)
184     {
185       m_filter.instanceAttach();
186       m_entity.instanceAttach(path_find_mapfile(path.begin(), path.end()));
187       m_entity.attach(m_keyObservers);
188     }
189   }
190   void instanceDetach(const scene::Path& path)
191   {
192     if(--m_instanceCounter.m_count == 0)
193     {
194       m_entity.detach(m_keyObservers);
195       m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
196       m_filter.instanceDetach();
197     }
198   }
199
200   EntityKeyValues& getEntity()
201   {
202     return m_entity;
203   }
204   const EntityKeyValues& getEntity() const
205   {
206     return m_entity;
207   }
208
209   Namespaced& getNamespaced()
210   {
211     return m_nameKeys;
212   }
213   Nameable& getNameable()
214   {
215     return m_named;
216   }
217   TransformNode& getTransformNode()
218   {
219     return m_transform;
220   }
221
222   const AABB& localAABB() const
223   {
224     return m_aabb_local;
225   }
226
227   VolumeIntersectionValue intersectVolume(const VolumeTest& volume, const Matrix4& localToWorld) const
228   {
229     return volume.TestAABB(localAABB(), localToWorld);
230   }
231
232   void renderArrow(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
233   {
234     if(g_showAngles)
235     {
236       renderer.addRenderable(m_arrow, localToWorld);
237     }
238   }
239   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
240   {
241     renderer.SetState(m_entity.getEntityClass().m_state_fill, Renderer::eFullMaterials);
242     renderer.addRenderable(m_aabb_solid, localToWorld);
243     renderArrow(renderer, volume, localToWorld);
244   }
245   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
246   {
247     renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
248     renderer.addRenderable(m_aabb_wire, localToWorld);
249     renderArrow(renderer, volume, localToWorld);
250     if(g_showNames)
251     {
252       renderer.addRenderable(m_renderName, localToWorld);
253     }
254   }
255
256
257   void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld)
258   {
259     test.BeginMesh(localToWorld);
260
261     SelectionIntersection best;
262     aabb_testselect(m_aabb_local, test, best);
263     if(best.valid())
264     {
265       selector.addIntersection(best);
266     }
267   }
268
269   void translate(const Vector3& translation)
270   {
271     m_origin = origin_translated(m_origin, translation);
272   }
273   void rotate(const Quaternion& rotation)
274   {
275     m_angles = angles_rotated(m_angles, rotation);
276   }
277   void snapto(float snap)
278   {
279     m_originKey.m_origin = origin_snapped(m_originKey.m_origin, snap);
280     m_originKey.write(&m_entity);
281   }
282   void revertTransform()
283   {
284     m_origin = m_originKey.m_origin;
285     m_angles = m_anglesKey.m_angles;
286   }
287   void freezeTransform()
288   {
289     m_originKey.m_origin = m_origin;
290     m_originKey.write(&m_entity);
291     m_anglesKey.m_angles = m_angles;
292     m_anglesKey.write(&m_entity);
293   }
294   void transformChanged()
295   {
296     revertTransform();
297     m_evaluateTransform();
298     updateTransform();
299   }
300   typedef MemberCaller<GenericEntity, &GenericEntity::transformChanged> TransformChangedCaller;
301 };
302
303 class GenericEntityInstance :
304   public TargetableInstance,
305   public TransformModifier,
306   public Renderable,
307   public SelectionTestable
308 {
309   class TypeCasts
310   {
311     InstanceTypeCastTable m_casts;
312   public:
313     TypeCasts()
314     {
315       m_casts = TargetableInstance::StaticTypeCasts::instance().get();
316       InstanceContainedCast<GenericEntityInstance, Bounded>::install(m_casts);
317       InstanceContainedCast<GenericEntityInstance, Cullable>::install(m_casts);
318       InstanceStaticCast<GenericEntityInstance, Renderable>::install(m_casts);
319       InstanceStaticCast<GenericEntityInstance, SelectionTestable>::install(m_casts);
320       InstanceStaticCast<GenericEntityInstance, Transformable>::install(m_casts);
321       InstanceIdentityCast<GenericEntityInstance>::install(m_casts);
322     }
323     InstanceTypeCastTable& get()
324     {
325       return m_casts;
326     }
327   };
328
329   GenericEntity& m_contained;
330   mutable AABB m_bounds;
331 public:
332
333   typedef LazyStatic<TypeCasts> StaticTypeCasts;
334
335   Bounded& get(NullType<Bounded>)
336   {
337     return m_contained;
338   }
339   Cullable& get(NullType<Cullable>)
340   {
341     return m_contained;
342   }
343
344   STRING_CONSTANT(Name, "GenericEntityInstance");
345
346   GenericEntityInstance(const scene::Path& path, scene::Instance* parent, GenericEntity& contained) :
347     TargetableInstance(path, parent, this, StaticTypeCasts::instance().get(), contained.getEntity(), *this),
348     TransformModifier(GenericEntity::TransformChangedCaller(contained), ApplyTransformCaller(*this)),
349     m_contained(contained)
350   {
351     m_contained.instanceAttach(Instance::path());
352
353     StaticRenderableConnectionLines::instance().attach(*this);
354   }
355   ~GenericEntityInstance()
356   {
357     StaticRenderableConnectionLines::instance().detach(*this);
358
359     m_contained.instanceDetach(Instance::path());
360   }
361
362   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
363   {
364     m_contained.renderSolid(renderer, volume, Instance::localToWorld());
365   }
366   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
367   {
368     m_contained.renderWireframe(renderer, volume, Instance::localToWorld());
369   }
370
371   void testSelect(Selector& selector, SelectionTest& test)
372   {
373     m_contained.testSelect(selector, test, Instance::localToWorld());
374   }
375
376   void evaluateTransform()
377   {
378     if(getType() == TRANSFORM_PRIMITIVE)
379     {
380       m_contained.translate(getTranslation());
381       m_contained.rotate(getRotation());
382     }
383   }
384   void applyTransform()
385   {
386     m_contained.revertTransform();
387     evaluateTransform();
388     m_contained.freezeTransform();
389   }
390   typedef MemberCaller<GenericEntityInstance, &GenericEntityInstance::applyTransform> ApplyTransformCaller;
391 };
392
393 class GenericEntityNode :
394   public scene::Node::Symbiot,
395   public scene::Instantiable,
396   public scene::Cloneable
397 {
398   class TypeCasts
399   {
400     NodeTypeCastTable m_casts;
401   public:
402     TypeCasts()
403     {
404       NodeStaticCast<GenericEntityNode, scene::Instantiable>::install(m_casts);
405       NodeStaticCast<GenericEntityNode, scene::Cloneable>::install(m_casts);
406       NodeContainedCast<GenericEntityNode, Snappable>::install(m_casts);
407       NodeContainedCast<GenericEntityNode, TransformNode>::install(m_casts);
408       NodeContainedCast<GenericEntityNode, Entity>::install(m_casts);
409       NodeContainedCast<GenericEntityNode, Nameable>::install(m_casts);
410       NodeContainedCast<GenericEntityNode, Namespaced>::install(m_casts);
411     }
412     NodeTypeCastTable& get()
413     {
414       return m_casts;
415     }
416   };
417
418
419   InstanceSet m_instances;
420
421   scene::Node m_node;
422   GenericEntity m_contained;
423
424 public:
425   typedef LazyStatic<TypeCasts> StaticTypeCasts;
426
427   Snappable& get(NullType<Snappable>)
428   {
429     return m_contained;
430   }
431   TransformNode& get(NullType<TransformNode>)
432   {
433     return m_contained.getTransformNode();
434   }
435   Entity& get(NullType<Entity>)
436   {
437     return m_contained.getEntity();
438   }
439   Nameable& get(NullType<Nameable>)
440   {
441     return m_contained.getNameable();
442   }
443   Namespaced& get(NullType<Namespaced>)
444   {
445     return m_contained.getNamespaced();
446   }
447
448   GenericEntityNode(EntityClass* eclass) :
449     m_node(this, this, StaticTypeCasts::instance().get()),
450     m_contained(eclass, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSetEvaluateTransform<GenericEntityInstance>::Caller(m_instances))
451   {
452   }
453   GenericEntityNode(const GenericEntityNode& other) :
454     scene::Node::Symbiot(other),
455     scene::Instantiable(other),
456     scene::Cloneable(other),
457     m_node(this, this, StaticTypeCasts::instance().get()),
458     m_contained(other.m_contained, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSetEvaluateTransform<GenericEntityInstance>::Caller(m_instances))
459   {
460   }
461   void release()
462   {
463     delete this;
464   }
465   scene::Node& node()
466   {
467     return m_node;
468   }
469
470   scene::Node& clone() const
471   {
472     return (new GenericEntityNode(*this))->node();
473   }
474
475   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
476   {
477     return new GenericEntityInstance(path, parent, m_contained);
478   }
479   void forEachInstance(const scene::Instantiable::Visitor& visitor)
480   {
481     m_instances.forEachInstance(visitor);
482   }
483   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
484   {
485     m_instances.insert(observer, path, instance);
486   }
487   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
488   {
489     return m_instances.erase(observer, path);
490   }
491 };
492
493 scene::Node& New_GenericEntity(EntityClass* eclass)
494 {
495   return (new GenericEntityNode(eclass))->node();
496 }