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