2318441feff634fd0e9aece64e58dbd976fb309b
[xonotic/netradiant.git] / plugins / entity / eclassmodel.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 displays a model (e.g. ammo_bfg).
24 ///
25 /// This entity displays the model specified in its entity-definition.
26 /// The "origin" and "angle" keys directly control the entity's local-to-parent transform.
27 /// The "rotation" key directly controls the entity's local-to-parent transform for Doom3 only.
28
29 #include "eclassmodel.h"
30
31 #include "cullable.h"
32 #include "renderable.h"
33 #include "editable.h"
34
35 #include "selectionlib.h"
36 #include "instancelib.h"
37 #include "transformlib.h"
38 #include "traverselib.h"
39 #include "entitylib.h"
40 #include "render.h"
41 #include "eclasslib.h"
42 #include "pivot.h"
43
44 #include "targetable.h"
45 #include "origin.h"
46 #include "angle.h"
47 #include "rotation.h"
48 #include "model.h"
49 #include "filters.h"
50 #include "namedentity.h"
51 #include "keyobservers.h"
52 #include "namekeys.h"
53 #include "modelskinkey.h"
54
55 #include "entity.h"
56
57 class EclassModel :
58   public Snappable
59 {
60   MatrixTransform m_transform;
61   EntityKeyValues m_entity;
62   KeyObserverMap m_keyObservers;
63
64   OriginKey m_originKey;
65   Vector3 m_origin;
66   AngleKey m_angleKey;
67   float m_angle;
68   RotationKey m_rotationKey;
69   Float9 m_rotation;
70   SingletonModel m_model;
71
72   ClassnameFilter m_filter;
73   NamedEntity m_named;
74   NameKeys m_nameKeys;
75   RenderablePivot m_renderOrigin;
76   RenderableNamedEntity m_renderName;
77   ModelSkinKey m_skin;
78
79   Callback m_transformChanged;
80   Callback m_evaluateTransform;
81
82   void construct()
83   {
84     default_rotation(m_rotation);
85
86     m_keyObservers.insert("classname", ClassnameFilter::ClassnameChangedCaller(m_filter));
87     m_keyObservers.insert(Static<KeyIsName>::instance().m_nameKey, NamedEntity::IdentifierChangedCaller(m_named));
88     if(g_gameType == eGameTypeDoom3)
89     {
90       m_keyObservers.insert("angle", RotationKey::AngleChangedCaller(m_rotationKey));
91       m_keyObservers.insert("rotation", RotationKey::RotationChangedCaller(m_rotationKey));
92     }
93     else
94     {
95       m_keyObservers.insert("angle", AngleKey::AngleChangedCaller(m_angleKey));
96     }
97     m_keyObservers.insert("origin", OriginKey::OriginChangedCaller(m_originKey));
98   }
99
100   void updateTransform()
101   {
102     m_transform.localToParent() = g_matrix4_identity;
103     matrix4_translate_by_vec3(m_transform.localToParent(), m_origin);
104
105     if(g_gameType == eGameTypeDoom3)
106     {
107       matrix4_multiply_by_matrix4(m_transform.localToParent(), rotation_toMatrix(m_rotation));
108     }
109     else
110     {
111       matrix4_multiply_by_matrix4(m_transform.localToParent(), matrix4_rotation_for_z_degrees(m_angle));
112     }
113
114     m_transformChanged();
115   }
116   typedef MemberCaller<EclassModel, &EclassModel::updateTransform> UpdateTransformCaller;
117
118   void originChanged()
119   {
120     m_origin = m_originKey.m_origin;
121     updateTransform();
122   }
123   typedef MemberCaller<EclassModel, &EclassModel::originChanged> OriginChangedCaller;
124   void angleChanged()
125   {
126     m_angle = m_angleKey.m_angle;
127     updateTransform();
128   }
129   typedef MemberCaller<EclassModel, &EclassModel::angleChanged> AngleChangedCaller;
130   void rotationChanged()
131   {
132     rotation_assign(m_rotation, m_rotationKey.m_rotation);
133     updateTransform();
134   }
135   typedef MemberCaller<EclassModel, &EclassModel::rotationChanged> RotationChangedCaller;
136
137   void skinChanged()
138   {
139     scene::Node* node = m_model.getNode();
140     if(node != 0)
141     {
142       Node_modelSkinChanged(*node);
143     }
144   }
145   typedef MemberCaller<EclassModel, &EclassModel::skinChanged> SkinChangedCaller;
146
147 public:
148
149   EclassModel(EntityClass* eclass, scene::Node& node, const Callback& transformChanged, const Callback& evaluateTransform) :
150     m_entity(eclass),
151     m_originKey(OriginChangedCaller(*this)),
152     m_origin(ORIGINKEY_IDENTITY),
153     m_angleKey(AngleChangedCaller(*this)),
154     m_angle(ANGLEKEY_IDENTITY),
155     m_rotationKey(RotationChangedCaller(*this)),
156     m_filter(m_entity, node),
157     m_named(m_entity),
158     m_nameKeys(m_entity),
159     m_renderName(m_named, g_vector3_identity),
160     m_skin(SkinChangedCaller(*this)),
161     m_transformChanged(transformChanged),
162     m_evaluateTransform(evaluateTransform)
163   {
164     construct();
165   }
166   EclassModel(const EclassModel& other, scene::Node& node, const Callback& transformChanged, const Callback& evaluateTransform) :
167     m_entity(other.m_entity),
168     m_originKey(OriginChangedCaller(*this)),
169     m_origin(ORIGINKEY_IDENTITY),
170     m_angleKey(AngleChangedCaller(*this)),
171     m_angle(ANGLEKEY_IDENTITY),
172     m_rotationKey(RotationChangedCaller(*this)),
173     m_filter(m_entity, node),
174     m_named(m_entity),
175     m_nameKeys(m_entity),
176     m_renderName(m_named, g_vector3_identity),
177     m_skin(SkinChangedCaller(*this)),
178     m_transformChanged(transformChanged),
179     m_evaluateTransform(evaluateTransform)
180   {
181     construct();
182   }
183
184   InstanceCounter m_instanceCounter;
185   void instanceAttach(const scene::Path& path)
186   {
187     if(++m_instanceCounter.m_count == 1)
188     {
189       m_filter.instanceAttach();
190       m_entity.instanceAttach(path_find_mapfile(path.begin(), path.end()));
191       m_entity.attach(m_keyObservers);
192       m_model.modelChanged(m_entity.getEntityClass().modelpath());
193       m_skin.skinChanged(m_entity.getEntityClass().skin());
194     }
195   }
196   void instanceDetach(const scene::Path& path)
197   {
198     if(--m_instanceCounter.m_count == 0)
199     {
200       m_skin.skinChanged("");
201       m_model.modelChanged("");
202       m_entity.detach(m_keyObservers);
203       m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
204       m_filter.instanceDetach();
205     }
206   }
207
208   EntityKeyValues& getEntity()
209   {
210     return m_entity;
211   }
212   const EntityKeyValues& getEntity() const
213   {
214     return m_entity;
215   }
216
217   scene::Traversable& getTraversable()
218   {
219     return m_model.getTraversable();
220   }
221   Namespaced& getNamespaced()
222   {
223     return m_nameKeys;
224   }
225   Nameable& getNameable()
226   {
227     return m_named;
228   }
229   TransformNode& getTransformNode()
230   {
231     return m_transform;
232   }
233   ModelSkin& getModelSkin()
234   {
235     return m_skin.get();
236   }
237
238   void attach(scene::Traversable::Observer* observer)
239   {
240     m_model.attach(observer);
241   }
242   void detach(scene::Traversable::Observer* observer)
243   {
244     m_model.detach(observer);
245   }
246
247   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
248   {
249     if(selected)
250     {
251       m_renderOrigin.render(renderer, volume, localToWorld);
252     }
253
254     renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
255   }
256   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
257   {
258     renderSolid(renderer, volume, localToWorld, selected);
259     if(g_showNames)
260     {
261       renderer.addRenderable(m_renderName, localToWorld);
262     }
263   }
264
265   void translate(const Vector3& translation)
266   {
267     m_origin = origin_translated(m_origin, translation);
268   }
269   void rotate(const Quaternion& rotation)
270   {
271     if(g_gameType == eGameTypeDoom3)
272     {
273       rotation_rotate(m_rotation, rotation);
274     }
275     else
276     {
277       m_angle = angle_rotated(m_angle, rotation);
278     }
279   }
280   void snapto(float snap)
281   {
282     m_originKey.m_origin = origin_snapped(m_originKey.m_origin, snap);
283     m_originKey.write(&m_entity);
284   }
285   void revertTransform()
286   {
287     m_origin = m_originKey.m_origin;
288     if(g_gameType == eGameTypeDoom3)
289     {
290       rotation_assign(m_rotation, m_rotationKey.m_rotation);
291     }
292     else
293     {
294       m_angle = m_angleKey.m_angle;
295     }
296   }
297   void freezeTransform()
298   {
299     m_originKey.m_origin = m_origin;
300     m_originKey.write(&m_entity);
301     if(g_gameType == eGameTypeDoom3)
302     {
303       rotation_assign(m_rotationKey.m_rotation, m_rotation);
304       m_rotationKey.write(&m_entity);
305     }
306     else
307     {
308       m_angleKey.m_angle = m_angle;
309       m_angleKey.write(&m_entity);
310     }
311   }
312   void transformChanged()
313   {
314     revertTransform();
315     m_evaluateTransform();
316     updateTransform();
317   }
318   typedef MemberCaller<EclassModel, &EclassModel::transformChanged> TransformChangedCaller;
319 };
320
321 class EclassModelInstance : public TargetableInstance, public TransformModifier, public Renderable
322 {
323   class TypeCasts
324   {
325     InstanceTypeCastTable m_casts;
326   public:
327     TypeCasts()
328     {
329       m_casts = TargetableInstance::StaticTypeCasts::instance().get();
330       InstanceStaticCast<EclassModelInstance, Renderable>::install(m_casts);
331       InstanceStaticCast<EclassModelInstance, Transformable>::install(m_casts);
332       InstanceIdentityCast<EclassModelInstance>::install(m_casts);
333     }
334     InstanceTypeCastTable& get()
335     {
336       return m_casts;
337     }
338   };
339
340   EclassModel& m_contained;
341 public:
342   typedef LazyStatic<TypeCasts> StaticTypeCasts;
343
344   STRING_CONSTANT(Name, "EclassModelInstance");
345
346   EclassModelInstance(const scene::Path& path, scene::Instance* parent, EclassModel& contained) :
347     TargetableInstance(path, parent, this, StaticTypeCasts::instance().get(), contained.getEntity(), *this),
348     TransformModifier(EclassModel::TransformChangedCaller(contained), ApplyTransformCaller(*this)),
349     m_contained(contained)
350   {
351     m_contained.instanceAttach(Instance::path());
352
353     StaticRenderableConnectionLines::instance().attach(*this);
354   }
355   ~EclassModelInstance()
356   {
357     StaticRenderableConnectionLines::instance().detach(*this);
358
359     m_contained.instanceDetach(Instance::path());
360   }
361   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
362   {
363     m_contained.renderSolid(renderer, volume, Instance::localToWorld(), getSelectable().isSelected());
364   }
365   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
366   {
367     m_contained.renderWireframe(renderer, volume, Instance::localToWorld(), getSelectable().isSelected());
368   }
369
370   void evaluateTransform()
371   {
372     if(getType() == TRANSFORM_PRIMITIVE)
373     {
374       m_contained.translate(getTranslation());
375       m_contained.rotate(getRotation());
376     }
377   }
378   void applyTransform()
379   {
380     m_contained.revertTransform();
381     evaluateTransform();
382     m_contained.freezeTransform();
383   }
384   typedef MemberCaller<EclassModelInstance, &EclassModelInstance::applyTransform> ApplyTransformCaller;
385 };
386
387 class EclassModelNode :
388   public scene::Node::Symbiot,
389   public scene::Instantiable,
390   public scene::Cloneable,
391   public scene::Traversable::Observer
392 {
393   class TypeCasts
394   {
395     NodeTypeCastTable m_casts;
396   public:
397     TypeCasts()
398     {
399       NodeStaticCast<EclassModelNode, scene::Instantiable>::install(m_casts);
400       NodeStaticCast<EclassModelNode, scene::Cloneable>::install(m_casts);
401       NodeContainedCast<EclassModelNode, scene::Traversable>::install(m_casts);
402       NodeContainedCast<EclassModelNode, Snappable>::install(m_casts);
403       NodeContainedCast<EclassModelNode, TransformNode>::install(m_casts);
404       NodeContainedCast<EclassModelNode, Entity>::install(m_casts);
405       NodeContainedCast<EclassModelNode, Nameable>::install(m_casts);
406       NodeContainedCast<EclassModelNode, Namespaced>::install(m_casts);
407       NodeContainedCast<EclassModelNode, ModelSkin>::install(m_casts);
408     }
409     NodeTypeCastTable& get()
410     {
411       return m_casts;
412     }
413   };
414
415
416   scene::Node m_node;
417   InstanceSet m_instances;
418   EclassModel m_contained;
419
420   void construct()
421   {
422     m_contained.attach(this);
423   }
424   void destroy()
425   {
426     m_contained.detach(this);
427   }
428
429 public:
430   typedef LazyStatic<TypeCasts> StaticTypeCasts;
431
432   scene::Traversable& get(NullType<scene::Traversable>)
433   {
434     return m_contained.getTraversable();
435   }
436   Snappable& get(NullType<Snappable>)
437   {
438     return m_contained;
439   }
440   TransformNode& get(NullType<TransformNode>)
441   {
442     return m_contained.getTransformNode();
443   }
444   Entity& get(NullType<Entity>)
445   {
446     return m_contained.getEntity();
447   }
448   Nameable& get(NullType<Nameable>)
449   {
450     return m_contained.getNameable();
451   }
452   Namespaced& get(NullType<Namespaced>)
453   {
454     return m_contained.getNamespaced();
455   }
456   ModelSkin& get(NullType<ModelSkin>)
457   {
458     return m_contained.getModelSkin();
459   }
460
461   EclassModelNode(EntityClass* eclass) :
462     m_node(this, this, StaticTypeCasts::instance().get()),
463     m_contained(eclass, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSetEvaluateTransform<EclassModelInstance>::Caller(m_instances))
464   {
465     construct();
466   }
467   EclassModelNode(const EclassModelNode& other) :
468     scene::Node::Symbiot(other),
469     scene::Instantiable(other),
470     scene::Cloneable(other),
471     scene::Traversable::Observer(other),
472     m_node(this, this, StaticTypeCasts::instance().get()),
473     m_contained(other.m_contained, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSetEvaluateTransform<EclassModelInstance>::Caller(m_instances))
474   {
475     construct();
476   }
477   ~EclassModelNode()
478   {
479     destroy();
480   }
481   void release()
482   {
483     delete this;
484   }
485   scene::Node& node()
486   {
487     return m_node;
488   }
489
490   void insert(scene::Node& child)
491   {
492     m_instances.insert(child);
493   }
494   void erase(scene::Node& child)
495   {
496     m_instances.erase(child);
497   }
498
499   scene::Node& clone() const
500   {
501     return (new EclassModelNode(*this))->node();
502   }
503
504   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
505   {
506     return new EclassModelInstance(path, parent, m_contained);
507   }
508   void forEachInstance(const scene::Instantiable::Visitor& visitor)
509   {
510     m_instances.forEachInstance(visitor);
511   }
512   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
513   {
514     m_instances.insert(observer, path, instance);
515   }
516   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
517   {
518     return m_instances.erase(observer, path);
519   }
520 };
521
522 scene::Node& New_EclassModel(EntityClass* eclass)
523 {
524   return (new EclassModelNode(eclass))->node();
525 }
526