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 // vc 2k5 compiler fix
 101 #if _MSC_VER >= 1400
 102         public:
 103 #endif
 104
 105   void updateTransform()
 106   {
 107     m_transform.localToParent() = g_matrix4_identity;
 108     matrix4_translate_by_vec3(m_transform.localToParent(), m_origin);
 109
 110     if(g_gameType == eGameTypeDoom3)
 111     {
 112       matrix4_multiply_by_matrix4(m_transform.localToParent(), rotation_toMatrix(m_rotation));
 113     }
 114     else
 115     {
 116       matrix4_multiply_by_matrix4(m_transform.localToParent(), matrix4_rotation_for_z_degrees(m_angle));
 117     }
 118
 119     m_transformChanged();
 120   }
 121   typedef MemberCaller<EclassModel, &EclassModel::updateTransform> UpdateTransformCaller;
 122
 123   void originChanged()
 124   {
 125     m_origin = m_originKey.m_origin;
 126     updateTransform();
 127   }
 128   typedef MemberCaller<EclassModel, &EclassModel::originChanged> OriginChangedCaller;
 129   void angleChanged()
 130   {
 131     m_angle = m_angleKey.m_angle;
 132     updateTransform();
 133   }
 134   typedef MemberCaller<EclassModel, &EclassModel::angleChanged> AngleChangedCaller;
 135   void rotationChanged()
 136   {
 137     rotation_assign(m_rotation, m_rotationKey.m_rotation);
 138     updateTransform();
 139   }
 140   typedef MemberCaller<EclassModel, &EclassModel::rotationChanged> RotationChangedCaller;
 141
 142   void skinChanged()
 143   {
 144     scene::Node* node = m_model.getNode();
 145     if(node != 0)
 146     {
 147       Node_modelSkinChanged(*node);
 148     }
 149   }
 150   typedef MemberCaller<EclassModel, &EclassModel::skinChanged> SkinChangedCaller;
 151
 152 public:
 153
 154   EclassModel(EntityClass* eclass, scene::Node& node, const Callback& transformChanged, const Callback& evaluateTransform) :
 155     m_entity(eclass),
 156     m_originKey(OriginChangedCaller(*this)),
 157     m_origin(ORIGINKEY_IDENTITY),
 158     m_angleKey(AngleChangedCaller(*this)),
 159     m_angle(ANGLEKEY_IDENTITY),
 160     m_rotationKey(RotationChangedCaller(*this)),
 161     m_filter(m_entity, node),
 162     m_named(m_entity),
 163     m_nameKeys(m_entity),
 164     m_renderName(m_named, g_vector3_identity),
 165     m_skin(SkinChangedCaller(*this)),
 166     m_transformChanged(transformChanged),
 167     m_evaluateTransform(evaluateTransform)
 168   {
 169     construct();
 170   }
 171   EclassModel(const EclassModel& other, scene::Node& node, const Callback& transformChanged, const Callback& evaluateTransform) :
 172     m_entity(other.m_entity),
 173     m_originKey(OriginChangedCaller(*this)),
 174     m_origin(ORIGINKEY_IDENTITY),
 175     m_angleKey(AngleChangedCaller(*this)),
 176     m_angle(ANGLEKEY_IDENTITY),
 177     m_rotationKey(RotationChangedCaller(*this)),
 178     m_filter(m_entity, node),
 179     m_named(m_entity),
 180     m_nameKeys(m_entity),
 181     m_renderName(m_named, g_vector3_identity),
 182     m_skin(SkinChangedCaller(*this)),
 183     m_transformChanged(transformChanged),
 184     m_evaluateTransform(evaluateTransform)
 185   {
 186     construct();
 187   }
 188
 189   InstanceCounter m_instanceCounter;
 190   void instanceAttach(const scene::Path& path)
 191   {
 192     if(++m_instanceCounter.m_count == 1)
 193     {
 194       m_filter.instanceAttach();
 195       m_entity.instanceAttach(path_find_mapfile(path.begin(), path.end()));
 196       m_entity.attach(m_keyObservers);
 197       m_model.modelChanged(m_entity.getEntityClass().modelpath());
 198       m_skin.skinChanged(m_entity.getEntityClass().skin());
 199     }
 200   }
 201   void instanceDetach(const scene::Path& path)
 202   {
 203     if(--m_instanceCounter.m_count == 0)
 204     {
 205       m_skin.skinChanged("");
 206       m_model.modelChanged("");
 207       m_entity.detach(m_keyObservers);
 208       m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
 209       m_filter.instanceDetach();
 210     }
 211   }
 212
 213   EntityKeyValues& getEntity()
 214   {
 215     return m_entity;
 216   }
 217   const EntityKeyValues& getEntity() const
 218   {
 219     return m_entity;
 220   }
 221
 222   scene::Traversable& getTraversable()
 223   {
 224     return m_model.getTraversable();
 225   }
 226   Namespaced& getNamespaced()
 227   {
 228     return m_nameKeys;
 229   }
 230   Nameable& getNameable()
 231   {
 232     return m_named;
 233   }
 234   TransformNode& getTransformNode()
 235   {
 236     return m_transform;
 237   }
 238   ModelSkin& getModelSkin()
 239   {
 240     return m_skin.get();
 241   }
 242
 243   void attach(scene::Traversable::Observer* observer)
 244   {
 245     m_model.attach(observer);
 246   }
 247   void detach(scene::Traversable::Observer* observer)
 248   {
 249     m_model.detach(observer);
 250   }
 251
 252   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
 253   {
 254     if(selected)
 255     {
 256       m_renderOrigin.render(renderer, volume, localToWorld);
 257     }
 258
 259     renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
 260   }
 261   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
 262   {
 263     renderSolid(renderer, volume, localToWorld, selected);
 264     if(g_showNames)
 265     {
 266       renderer.addRenderable(m_renderName, localToWorld);
 267     }
 268   }
 269
 270   void translate(const Vector3& translation)
 271   {
 272     m_origin = origin_translated(m_origin, translation);
 273   }
 274   void rotate(const Quaternion& rotation)
 275   {
 276     if(g_gameType == eGameTypeDoom3)
 277     {
 278       rotation_rotate(m_rotation, rotation);
 279     }
 280     else
 281     {
 282       m_angle = angle_rotated(m_angle, rotation);
 283     }
 284   }
 285   void snapto(float snap)
 286   {
 287     m_originKey.m_origin = origin_snapped(m_originKey.m_origin, snap);
 288     m_originKey.write(&m_entity);
 289   }
 290   void revertTransform()
 291   {
 292     m_origin = m_originKey.m_origin;
 293     if(g_gameType == eGameTypeDoom3)
 294     {
 295       rotation_assign(m_rotation, m_rotationKey.m_rotation);
 296     }
 297     else
 298     {
 299       m_angle = m_angleKey.m_angle;
 300     }
 301   }
 302   void freezeTransform()
 303   {
 304     m_originKey.m_origin = m_origin;
 305     m_originKey.write(&m_entity);
 306     if(g_gameType == eGameTypeDoom3)
 307     {
 308       rotation_assign(m_rotationKey.m_rotation, m_rotation);
 309       m_rotationKey.write(&m_entity);
 310     }
 311     else
 312     {
 313       m_angleKey.m_angle = m_angle;
 314       m_angleKey.write(&m_entity);
 315     }
 316   }
 317   void transformChanged()
 318   {
 319     revertTransform();
 320     m_evaluateTransform();
 321     updateTransform();
 322   }
 323   typedef MemberCaller<EclassModel, &EclassModel::transformChanged> TransformChangedCaller;
 324 };
 325
 326 class EclassModelInstance : public TargetableInstance, public TransformModifier, public Renderable
 327 {
 328   class TypeCasts
 329   {
 330     InstanceTypeCastTable m_casts;
 331   public:
 332     TypeCasts()
 333     {
 334       m_casts = TargetableInstance::StaticTypeCasts::instance().get();
 335       InstanceStaticCast<EclassModelInstance, Renderable>::install(m_casts);
 336       InstanceStaticCast<EclassModelInstance, Transformable>::install(m_casts);
 337       InstanceIdentityCast<EclassModelInstance>::install(m_casts);
 338     }
 339     InstanceTypeCastTable& get()
 340     {
 341       return m_casts;
 342     }
 343   };
 344
 345   EclassModel& m_contained;
 346 public:
 347   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 348
 349   STRING_CONSTANT(Name, "EclassModelInstance");
 350
 351   EclassModelInstance(const scene::Path& path, scene::Instance* parent, EclassModel& contained) :
 352     TargetableInstance(path, parent, this, StaticTypeCasts::instance().get(), contained.getEntity(), *this),
 353     TransformModifier(EclassModel::TransformChangedCaller(contained), ApplyTransformCaller(*this)),
 354     m_contained(contained)
 355   {
 356     m_contained.instanceAttach(Instance::path());
 357
 358     StaticRenderableConnectionLines::instance().attach(*this);
 359   }
 360   ~EclassModelInstance()
 361   {
 362     StaticRenderableConnectionLines::instance().detach(*this);
 363
 364     m_contained.instanceDetach(Instance::path());
 365   }
 366   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
 367   {
 368     m_contained.renderSolid(renderer, volume, Instance::localToWorld(), getSelectable().isSelected());
 369   }
 370   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
 371   {
 372     m_contained.renderWireframe(renderer, volume, Instance::localToWorld(), getSelectable().isSelected());
 373   }
 374
 375   void evaluateTransform()
 376   {
 377     if(getType() == TRANSFORM_PRIMITIVE)
 378     {
 379       m_contained.translate(getTranslation());
 380       m_contained.rotate(getRotation());
 381     }
 382   }
 383   void applyTransform()
 384   {
 385     m_contained.revertTransform();
 386     evaluateTransform();
 387     m_contained.freezeTransform();
 388   }
 389   typedef MemberCaller<EclassModelInstance, &EclassModelInstance::applyTransform> ApplyTransformCaller;
 390 };
 391
 392 class EclassModelNode :
 393   public scene::Node::Symbiot,
 394   public scene::Instantiable,
 395   public scene::Cloneable,
 396   public scene::Traversable::Observer
 397 {
 398   class TypeCasts
 399   {
 400     NodeTypeCastTable m_casts;
 401   public:
 402     TypeCasts()
 403     {
 404       NodeStaticCast<EclassModelNode, scene::Instantiable>::install(m_casts);
 405       NodeStaticCast<EclassModelNode, scene::Cloneable>::install(m_casts);
 406       NodeContainedCast<EclassModelNode, scene::Traversable>::install(m_casts);
 407       NodeContainedCast<EclassModelNode, Snappable>::install(m_casts);
 408       NodeContainedCast<EclassModelNode, TransformNode>::install(m_casts);
 409       NodeContainedCast<EclassModelNode, Entity>::install(m_casts);
 410       NodeContainedCast<EclassModelNode, Nameable>::install(m_casts);
 411       NodeContainedCast<EclassModelNode, Namespaced>::install(m_casts);
 412       NodeContainedCast<EclassModelNode, ModelSkin>::install(m_casts);
 413     }
 414     NodeTypeCastTable& get()
 415     {
 416       return m_casts;
 417     }
 418   };
 419
 420
 421   scene::Node m_node;
 422   InstanceSet m_instances;
 423   EclassModel m_contained;
 424
 425   void construct()
 426   {
 427     m_contained.attach(this);
 428   }
 429   void destroy()
 430   {
 431     m_contained.detach(this);
 432   }
 433
 434 public:
 435   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 436
 437   scene::Traversable& get(NullType<scene::Traversable>)
 438   {
 439     return m_contained.getTraversable();
 440   }
 441   Snappable& get(NullType<Snappable>)
 442   {
 443     return m_contained;
 444   }
 445   TransformNode& get(NullType<TransformNode>)
 446   {
 447     return m_contained.getTransformNode();
 448   }
 449   Entity& get(NullType<Entity>)
 450   {
 451     return m_contained.getEntity();
 452   }
 453   Nameable& get(NullType<Nameable>)
 454   {
 455     return m_contained.getNameable();
 456   }
 457   Namespaced& get(NullType<Namespaced>)
 458   {
 459     return m_contained.getNamespaced();
 460   }
 461   ModelSkin& get(NullType<ModelSkin>)
 462   {
 463     return m_contained.getModelSkin();
 464   }
 465
 466   EclassModelNode(EntityClass* eclass) :
 467     m_node(this, this, StaticTypeCasts::instance().get()),
 468     m_contained(eclass, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSetEvaluateTransform<EclassModelInstance>::Caller(m_instances))
 469   {
 470     construct();
 471   }
 472   EclassModelNode(const EclassModelNode& other) :
 473     scene::Node::Symbiot(other),
 474     scene::Instantiable(other),
 475     scene::Cloneable(other),
 476     scene::Traversable::Observer(other),
 477     m_node(this, this, StaticTypeCasts::instance().get()),
 478     m_contained(other.m_contained, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSetEvaluateTransform<EclassModelInstance>::Caller(m_instances))
 479   {
 480     construct();
 481   }
 482   ~EclassModelNode()
 483   {
 484     destroy();
 485   }
 486   void release()
 487   {
 488     delete this;
 489   }
 490   scene::Node& node()
 491   {
 492     return m_node;
 493   }
 494
 495   void insert(scene::Node& child)
 496   {
 497     m_instances.insert(child);
 498   }
 499   void erase(scene::Node& child)
 500   {
 501     m_instances.erase(child);
 502   }
 503
 504   scene::Node& clone() const
 505   {
 506     return (new EclassModelNode(*this))->node();
 507   }
 508
 509   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
 510   {
 511     return new EclassModelInstance(path, parent, m_contained);
 512   }
 513   void forEachInstance(const scene::Instantiable::Visitor& visitor)
 514   {
 515     m_instances.forEachInstance(visitor);
 516   }
 517   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
 518   {
 519     m_instances.insert(observer, path, instance);
 520   }
 521   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
 522   {
 523     return m_instances.erase(observer, path);
 524   }
 525 };
 526
 527 scene::Node& New_EclassModel(EntityClass* eclass)
 528 {
 529   return (new EclassModelNode(eclass))->node();
 530 }
 531
 532