plugins/entity/doom3group.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 Doom3 entity which does not have a fixed size specified in its entity-definition (e.g. func_static).
  24 ///
  25 /// This entity behaves as a group only when the "model" key is empty or is the same as the "name" key. Otherwise it behaves as a model.
  26 /// When behaving as a group, the "origin" key is the translation to be applied to all brushes (not patches) grouped under this entity.
  27 /// When behaving as a model, the "origin", "angle" and "rotation" keys directly control the entity's local-to-parent transform.
  28 /// When either the "curve_Nurbs" or "curve_CatmullRomSpline" keys define a curve, the curve is rendered and can be edited.
  29
  30 #include "doom3group.h"
  31
  32 #include "cullable.h"
  33 #include "renderable.h"
  34 #include "editable.h"
  35 #include "modelskin.h"
  36
  37 #include "selectionlib.h"
  38 #include "instancelib.h"
  39 #include "transformlib.h"
  40 #include "traverselib.h"
  41 #include "entitylib.h"
  42 #include "render.h"
  43 #include "eclasslib.h"
  44 #include "stream/stringstream.h"
  45 #include "pivot.h"
  46
  47 #include "targetable.h"
  48 #include "origin.h"
  49 #include "angle.h"
  50 #include "rotation.h"
  51 #include "model.h"
  52 #include "filters.h"
  53 #include "namedentity.h"
  54 #include "keyobservers.h"
  55 #include "namekeys.h"
  56 #include "curve.h"
  57 #include "modelskinkey.h"
  58
  59 #include "entity.h"
  60
  61 inline void PointVertexArray_testSelect(PointVertex* first, std::size_t count, SelectionTest& test, SelectionIntersection& best)
  62 {
  63   test.TestLineStrip(
  64     VertexPointer(
  65       reinterpret_cast<VertexPointer::pointer>(&first->vertex),
  66       sizeof(PointVertex)
  67     ),
  68     IndexPointer::index_type(count),
  69     best
  70   );
  71 }
  72
  73 class Doom3Group :
  74   public Bounded,
  75   public Snappable
  76 {
  77   EntityKeyValues m_entity;
  78   KeyObserverMap m_keyObservers;
  79   TraversableNodeSet m_traverse;
  80   MatrixTransform m_transform;
  81
  82   SingletonModel m_model;
  83   OriginKey m_originKey;
  84   Vector3 m_origin;
  85
  86   RotationKey m_rotationKey;
  87   Float9 m_rotation;
  88
  89   ClassnameFilter m_filter;
  90   NamedEntity m_named;
  91   NameKeys m_nameKeys;
  92   TraversableObserverPairRelay m_traverseObservers;
  93   Doom3GroupOrigin m_funcStaticOrigin;
  94   RenderablePivot m_renderOrigin;
  95   RenderableNamedEntity m_renderName;
  96   mutable Vector3 m_name_origin;
  97   ModelSkinKey m_skin;
  98
  99 public:
 100   NURBSCurve m_curveNURBS;
 101   SignalHandlerId m_curveNURBSChanged;
 102   CatmullRomSpline m_curveCatmullRom;
 103   SignalHandlerId m_curveCatmullRomChanged;
 104 private:
 105   mutable AABB m_curveBounds;
 106
 107   Callback m_transformChanged;
 108   Callback m_evaluateTransform;
 109
 110   CopiedString m_name;
 111   CopiedString m_modelKey;
 112   bool m_isModel;
 113
 114   scene::Traversable* m_traversable;
 115
 116   void construct()
 117   {
 118     default_rotation(m_rotation);
 119
 120     m_keyObservers.insert("classname", ClassnameFilter::ClassnameChangedCaller(m_filter));
 121     m_keyObservers.insert(Static<KeyIsName>::instance().m_nameKey, NamedEntity::IdentifierChangedCaller(m_named));
 122     m_keyObservers.insert("model", Doom3Group::ModelChangedCaller(*this));
 123     m_keyObservers.insert("origin", OriginKey::OriginChangedCaller(m_originKey));
 124     m_keyObservers.insert("angle", RotationKey::AngleChangedCaller(m_rotationKey));
 125     m_keyObservers.insert("rotation", RotationKey::RotationChangedCaller(m_rotationKey));
 126     m_keyObservers.insert("name", NameChangedCaller(*this));
 127     m_keyObservers.insert(curve_Nurbs, NURBSCurve::CurveChangedCaller(m_curveNURBS));
 128     m_keyObservers.insert(curve_CatmullRomSpline, CatmullRomSpline::CurveChangedCaller(m_curveCatmullRom));
 129     m_keyObservers.insert("skin", ModelSkinKey::SkinChangedCaller(m_skin));
 130
 131     m_traverseObservers.attach(m_funcStaticOrigin);
 132     m_isModel = false;
 133     m_nameKeys.setKeyIsName(keyIsNameDoom3Doom3Group);
 134     attachTraverse();
 135
 136     m_entity.attach(m_keyObservers);
 137   }
 138   void destroy()
 139   {
 140     m_entity.detach(m_keyObservers);
 141
 142     if(isModel())
 143     {
 144       detachModel();
 145     }
 146     else
 147     {
 148       detachTraverse();
 149     }
 150
 151     m_traverseObservers.detach(m_funcStaticOrigin);
 152   }
 153
 154   void attachModel()
 155   {
 156     m_traversable = &m_model.getTraversable();
 157     m_model.attach(&m_traverseObservers);
 158   }
 159   void detachModel()
 160   {
 161     m_traversable = 0;
 162     m_model.detach(&m_traverseObservers);
 163   }
 164   void attachTraverse()
 165   {
 166     m_traversable = &m_traverse;
 167     m_traverse.attach(&m_traverseObservers);
 168   }
 169   void detachTraverse()
 170   {
 171     m_traversable = 0;
 172     m_traverse.detach(&m_traverseObservers);
 173   }
 174
 175   bool isModel() const
 176   {
 177     return m_isModel;
 178   }
 179
 180   void setIsModel(bool newValue)
 181   {
 182     if(newValue && !m_isModel)
 183     {
 184       detachTraverse();
 185       attachModel();
 186
 187       m_nameKeys.setKeyIsName(Static<KeyIsName>::instance().m_keyIsName);
 188       m_model.modelChanged(m_modelKey.c_str());
 189     }
 190     else if(!newValue && m_isModel)
 191     {
 192       detachModel();
 193       attachTraverse();
 194
 195       m_nameKeys.setKeyIsName(keyIsNameDoom3Doom3Group);
 196     }
 197     m_isModel = newValue;
 198     updateTransform();
 199   }
 200
 201   void updateIsModel()
 202   {
 203     setIsModel(!string_equal(m_modelKey.c_str(), m_name.c_str()));
 204   }
 205
 206 // vc 2k5 compiler fix
 207 #if _MSC_VER >= 1400
 208         public:
 209 #endif
 210
 211   void nameChanged(const char* value)
 212   {
 213     m_name = value;
 214     updateIsModel();
 215   }
 216   typedef MemberCaller1<Doom3Group, const char*, &Doom3Group::nameChanged> NameChangedCaller;
 217
 218   void modelChanged(const char* value)
 219   {
 220     m_modelKey = value;
 221     updateIsModel();
 222     if(isModel())
 223     {
 224       m_model.modelChanged(value);
 225     }
 226     else
 227     {
 228       m_model.modelChanged("");
 229     }
 230   }
 231   typedef MemberCaller1<Doom3Group, const char*, &Doom3Group::modelChanged> ModelChangedCaller;
 232
 233   void updateTransform()
 234   {
 235     m_transform.localToParent() = g_matrix4_identity;
 236     if(isModel())
 237     {
 238       matrix4_translate_by_vec3(m_transform.localToParent(), m_origin);
 239       matrix4_multiply_by_matrix4(m_transform.localToParent(), rotation_toMatrix(m_rotation));
 240     }
 241     m_transformChanged();
 242     if(!isModel())
 243     {
 244       m_funcStaticOrigin.originChanged();
 245     }
 246   }
 247   typedef MemberCaller<Doom3Group, &Doom3Group::updateTransform> UpdateTransformCaller;
 248
 249   void originChanged()
 250   {
 251     m_origin = m_originKey.m_origin;
 252     updateTransform();
 253   }
 254   typedef MemberCaller<Doom3Group, &Doom3Group::originChanged> OriginChangedCaller;
 255
 256   void rotationChanged()
 257   {
 258     rotation_assign(m_rotation, m_rotationKey.m_rotation);
 259     updateTransform();
 260   }
 261   typedef MemberCaller<Doom3Group, &Doom3Group::rotationChanged> RotationChangedCaller;
 262
 263   void skinChanged()
 264   {
 265     if(isModel())
 266     {
 267       scene::Node* node = m_model.getNode();
 268       if(node != 0)
 269       {
 270         Node_modelSkinChanged(*node);
 271       }
 272     }
 273   }
 274   typedef MemberCaller<Doom3Group, &Doom3Group::skinChanged> SkinChangedCaller;
 275
 276 public:
 277   Doom3Group(EntityClass* eclass, scene::Node& node, const Callback& transformChanged, const Callback& boundsChanged, const Callback& evaluateTransform) :
 278     m_entity(eclass),
 279     m_originKey(OriginChangedCaller(*this)),
 280     m_origin(ORIGINKEY_IDENTITY),
 281     m_rotationKey(RotationChangedCaller(*this)),
 282     m_filter(m_entity, node),
 283     m_named(m_entity),
 284     m_nameKeys(m_entity),
 285     m_funcStaticOrigin(m_traverse, m_origin),
 286     m_renderName(m_named, m_name_origin),
 287         m_name_origin(g_vector3_identity),
 288     m_skin(SkinChangedCaller(*this)),
 289     m_curveNURBS(boundsChanged),
 290     m_curveCatmullRom(boundsChanged),
 291     m_transformChanged(transformChanged),
 292     m_evaluateTransform(evaluateTransform),
 293     m_traversable(0)
 294   {
 295     construct();
 296   }
 297   Doom3Group(const Doom3Group& other, scene::Node& node, const Callback& transformChanged, const Callback& boundsChanged, const Callback& evaluateTransform) :
 298     m_entity(other.m_entity),
 299     m_originKey(OriginChangedCaller(*this)),
 300     m_origin(ORIGINKEY_IDENTITY),
 301     m_rotationKey(RotationChangedCaller(*this)),
 302     m_filter(m_entity, node),
 303     m_named(m_entity),
 304     m_nameKeys(m_entity),
 305     m_funcStaticOrigin(m_traverse, m_origin),
 306     m_renderName(m_named, g_vector3_identity),
 307     m_skin(SkinChangedCaller(*this)),
 308     m_curveNURBS(boundsChanged),
 309     m_curveCatmullRom(boundsChanged),
 310     m_transformChanged(transformChanged),
 311     m_evaluateTransform(evaluateTransform),
 312     m_traversable(0)
 313   {
 314     construct();
 315   }
 316   ~Doom3Group()
 317   {
 318     destroy();
 319   }
 320
 321   InstanceCounter m_instanceCounter;
 322   void instanceAttach(const scene::Path& path)
 323   {
 324     if(++m_instanceCounter.m_count == 1)
 325     {
 326       m_filter.instanceAttach();
 327       m_entity.instanceAttach(path_find_mapfile(path.begin(), path.end()));
 328       m_traverse.instanceAttach(path_find_mapfile(path.begin(), path.end()));
 329
 330       m_funcStaticOrigin.enable();
 331     }
 332   }
 333   void instanceDetach(const scene::Path& path)
 334   {
 335     if(--m_instanceCounter.m_count == 0)
 336     {
 337       m_funcStaticOrigin.disable();
 338
 339       m_traverse.instanceDetach(path_find_mapfile(path.begin(), path.end()));
 340       m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
 341       m_filter.instanceDetach();
 342     }
 343   }
 344
 345   EntityKeyValues& getEntity()
 346   {
 347     return m_entity;
 348   }
 349   const EntityKeyValues& getEntity() const
 350   {
 351     return m_entity;
 352   }
 353
 354   scene::Traversable& getTraversable()
 355   {
 356     return *m_traversable;
 357   }
 358   Namespaced& getNamespaced()
 359   {
 360     return m_nameKeys;
 361   }
 362   Nameable& getNameable()
 363   {
 364     return m_named;
 365   }
 366   TransformNode& getTransformNode()
 367   {
 368     return m_transform;
 369   }
 370   ModelSkin& getModelSkin()
 371   {
 372     return m_skin.get();
 373   }
 374
 375   void attach(scene::Traversable::Observer* observer)
 376   {
 377     m_traverseObservers.attach(*observer);
 378   }
 379   void detach(scene::Traversable::Observer* observer)
 380   {
 381     m_traverseObservers.detach(*observer);
 382   }
 383
 384   const AABB& localAABB() const
 385   {
 386     m_curveBounds = m_curveNURBS.m_bounds;
 387     aabb_extend_by_aabb_safe(m_curveBounds, m_curveCatmullRom.m_bounds);
 388     return m_curveBounds;
 389   }
 390
 391   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected) const
 392   {
 393     if(isModel() && selected)
 394     {
 395       m_renderOrigin.render(renderer, volume, localToWorld);
 396     }
 397
 398     renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
 399     renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eFullMaterials);
 400
 401     if(!m_curveNURBS.m_renderCurve.m_vertices.empty())
 402     {
 403       renderer.addRenderable(m_curveNURBS.m_renderCurve, localToWorld);
 404     }
 405     if(!m_curveCatmullRom.m_renderCurve.m_vertices.empty())
 406     {
 407       renderer.addRenderable(m_curveCatmullRom.m_renderCurve, localToWorld);
 408     }
 409   }
 410
 411   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, bool selected, const AABB& childBounds) const
 412   {
 413     renderSolid(renderer, volume, localToWorld, selected);
 414
 415     if(g_showNames)
 416     {
 417       // draw models as usual
 418       if(!isModel())
 419       {
 420         // don't draw the name for worldspawn
 421         if(!strcmp(m_entity.getEntityClass().name(), "worldspawn"))
 422             return;
 423
 424                 // place name in the middle of the "children cloud"
 425                 m_name_origin = childBounds.origin;
 426       }
 427
 428       renderer.addRenderable(m_renderName, localToWorld);
 429     }
 430   }
 431
 432   void testSelect(Selector& selector, SelectionTest& test, SelectionIntersection& best)
 433   {
 434     PointVertexArray_testSelect(&m_curveNURBS.m_renderCurve.m_vertices[0], m_curveNURBS.m_renderCurve.m_vertices.size(), test, best);
 435     PointVertexArray_testSelect(&m_curveCatmullRom.m_renderCurve.m_vertices[0], m_curveCatmullRom.m_renderCurve.m_vertices.size(), test, best);
 436   }
 437
 438   void translate(const Vector3& translation)
 439   {
 440     m_origin = origin_translated(m_origin, translation);
 441   }
 442   void rotate(const Quaternion& rotation)
 443   {
 444     rotation_rotate(m_rotation, rotation);
 445   }
 446   void snapto(float snap)
 447   {
 448     m_originKey.m_origin = origin_snapped(m_originKey.m_origin, snap);
 449     m_originKey.write(&m_entity);
 450   }
 451   void revertTransform()
 452   {
 453     m_origin = m_originKey.m_origin;
 454     rotation_assign(m_rotation, m_rotationKey.m_rotation);
 455     m_curveNURBS.m_controlPointsTransformed = m_curveNURBS.m_controlPoints;
 456     m_curveCatmullRom.m_controlPointsTransformed = m_curveCatmullRom.m_controlPoints;
 457   }
 458   void freezeTransform()
 459   {
 460     m_originKey.m_origin = m_origin;
 461     m_originKey.write(&m_entity);
 462     rotation_assign(m_rotationKey.m_rotation, m_rotation);
 463     m_rotationKey.write(&m_entity);
 464     m_curveNURBS.m_controlPoints = m_curveNURBS.m_controlPointsTransformed;
 465     ControlPoints_write(m_curveNURBS.m_controlPoints, curve_Nurbs, m_entity);
 466     m_curveCatmullRom.m_controlPoints = m_curveCatmullRom.m_controlPointsTransformed;
 467     ControlPoints_write(m_curveCatmullRom.m_controlPoints, curve_CatmullRomSpline, m_entity);
 468   }
 469   void transformChanged()
 470   {
 471     revertTransform();
 472     m_evaluateTransform();
 473     updateTransform();
 474     m_curveNURBS.curveChanged();
 475     m_curveCatmullRom.curveChanged();
 476   }
 477   typedef MemberCaller<Doom3Group, &Doom3Group::transformChanged> TransformChangedCaller;
 478 };
 479
 480 class ControlPointAddBounds
 481 {
 482   AABB& m_bounds;
 483 public:
 484   ControlPointAddBounds(AABB& bounds) : m_bounds(bounds)
 485   {
 486   }
 487   void operator()(const Vector3& point) const
 488   {
 489     aabb_extend_by_point_safe(m_bounds, point);
 490   }
 491 };
 492
 493 class Doom3GroupInstance :
 494   public TargetableInstance,
 495   public TransformModifier,
 496   public Renderable,
 497   public SelectionTestable,
 498   public ComponentSelectionTestable,
 499   public ComponentEditable,
 500   public ComponentSnappable
 501 {
 502   class TypeCasts
 503   {
 504     InstanceTypeCastTable m_casts;
 505   public:
 506     TypeCasts()
 507     {
 508       m_casts = TargetableInstance::StaticTypeCasts::instance().get();
 509       InstanceContainedCast<Doom3GroupInstance, Bounded>::install(m_casts);
 510       InstanceStaticCast<Doom3GroupInstance, Renderable>::install(m_casts);
 511       InstanceStaticCast<Doom3GroupInstance, SelectionTestable>::install(m_casts);
 512       InstanceStaticCast<Doom3GroupInstance, ComponentSelectionTestable>::install(m_casts);
 513       InstanceStaticCast<Doom3GroupInstance, ComponentEditable>::install(m_casts);
 514       InstanceStaticCast<Doom3GroupInstance, ComponentSnappable>::install(m_casts);
 515       InstanceStaticCast<Doom3GroupInstance, Transformable>::install(m_casts);
 516       InstanceIdentityCast<Doom3GroupInstance>::install(m_casts);
 517     }
 518     InstanceTypeCastTable& get()
 519     {
 520       return m_casts;
 521     }
 522   };
 523
 524   Doom3Group& m_contained;
 525   CurveEdit m_curveNURBS;
 526   CurveEdit m_curveCatmullRom;
 527   mutable AABB m_aabb_component;
 528 public:
 529
 530   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 531
 532
 533   Bounded& get(NullType<Bounded>)
 534   {
 535     return m_contained;
 536   }
 537
 538   STRING_CONSTANT(Name, "Doom3GroupInstance");
 539
 540   Doom3GroupInstance(const scene::Path& path, scene::Instance* parent, Doom3Group& contained) :
 541     TargetableInstance(path, parent, this, StaticTypeCasts::instance().get(), contained.getEntity(), *this),
 542     TransformModifier(Doom3Group::TransformChangedCaller(contained), ApplyTransformCaller(*this)),
 543     m_contained(contained),
 544     m_curveNURBS(m_contained.m_curveNURBS.m_controlPointsTransformed, SelectionChangedComponentCaller(*this)),
 545     m_curveCatmullRom(m_contained.m_curveCatmullRom.m_controlPointsTransformed, SelectionChangedComponentCaller(*this))
 546   {
 547     m_contained.instanceAttach(Instance::path());
 548     m_contained.m_curveNURBSChanged = m_contained.m_curveNURBS.connect(CurveEdit::CurveChangedCaller(m_curveNURBS));
 549     m_contained.m_curveCatmullRomChanged = m_contained.m_curveCatmullRom.connect(CurveEdit::CurveChangedCaller(m_curveCatmullRom));
 550
 551     StaticRenderableConnectionLines::instance().attach(*this);
 552   }
 553   ~Doom3GroupInstance()
 554   {
 555     StaticRenderableConnectionLines::instance().detach(*this);
 556
 557     m_contained.m_curveCatmullRom.disconnect(m_contained.m_curveCatmullRomChanged);
 558     m_contained.m_curveNURBS.disconnect(m_contained.m_curveNURBSChanged);
 559     m_contained.instanceDetach(Instance::path());
 560   }
 561   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
 562   {
 563     m_contained.renderSolid(renderer, volume, Instance::localToWorld(), getSelectable().isSelected());
 564
 565     m_curveNURBS.renderComponentsSelected(renderer, volume, localToWorld());
 566     m_curveCatmullRom.renderComponentsSelected(renderer, volume, localToWorld());
 567   }
 568   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
 569   {
 570         m_contained.renderWireframe(renderer, volume, Instance::localToWorld(), getSelectable().isSelected(), Instance::childBounds());
 571
 572     m_curveNURBS.renderComponentsSelected(renderer, volume, localToWorld());
 573     m_curveCatmullRom.renderComponentsSelected(renderer, volume, localToWorld());
 574   }
 575   void renderComponents(Renderer& renderer, const VolumeTest& volume) const
 576   {
 577     if(GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex)
 578     {
 579       m_curveNURBS.renderComponents(renderer, volume, localToWorld());
 580       m_curveCatmullRom.renderComponents(renderer, volume, localToWorld());
 581     }
 582   }
 583
 584   void testSelect(Selector& selector, SelectionTest& test)
 585   {
 586     test.BeginMesh(localToWorld());
 587     SelectionIntersection best;
 588
 589     m_contained.testSelect(selector, test, best);
 590
 591     if(best.valid())
 592     {
 593       Selector_add(selector, getSelectable(), best);
 594     }
 595   }
 596
 597   bool isSelectedComponents() const
 598   {
 599     return m_curveNURBS.isSelected() || m_curveCatmullRom.isSelected();
 600   }
 601   void setSelectedComponents(bool selected, SelectionSystem::EComponentMode mode)
 602   {
 603     if(mode == SelectionSystem::eVertex)
 604     {
 605       m_curveNURBS.setSelected(selected);
 606       m_curveCatmullRom.setSelected(selected);
 607     }
 608   }
 609   void testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode)
 610   {
 611     if(mode == SelectionSystem::eVertex)
 612     {
 613       test.BeginMesh(localToWorld());
 614       m_curveNURBS.testSelect(selector, test);
 615       m_curveCatmullRom.testSelect(selector, test);
 616     }
 617   }
 618
 619   void transformComponents(const Matrix4& matrix)
 620   {
 621     if(m_curveNURBS.isSelected())
 622     {
 623       m_curveNURBS.transform(matrix);
 624     }
 625     if(m_curveCatmullRom.isSelected())
 626     {
 627       m_curveCatmullRom.transform(matrix);
 628     }
 629   }
 630
 631   const AABB& getSelectedComponentsBounds() const
 632   {
 633     m_aabb_component = AABB();
 634     m_curveNURBS.forEachSelected(ControlPointAddBounds(m_aabb_component));
 635     m_curveCatmullRom.forEachSelected(ControlPointAddBounds(m_aabb_component));
 636     return m_aabb_component;
 637   }
 638
 639   void snapComponents(float snap)
 640   {
 641     if(m_curveNURBS.isSelected())
 642     {
 643       m_curveNURBS.snapto(snap);
 644       m_curveNURBS.write(curve_Nurbs, m_contained.getEntity());
 645     }
 646     if(m_curveCatmullRom.isSelected())
 647     {
 648       m_curveCatmullRom.snapto(snap);
 649       m_curveCatmullRom.write(curve_CatmullRomSpline, m_contained.getEntity());
 650     }
 651   }
 652
 653   void evaluateTransform()
 654   {
 655     if(getType() == TRANSFORM_PRIMITIVE)
 656     {
 657       m_contained.translate(getTranslation());
 658       m_contained.rotate(getRotation());
 659     }
 660     else
 661     {
 662       transformComponents(calculateTransform());
 663     }
 664   }
 665   void applyTransform()
 666   {
 667     m_contained.revertTransform();
 668     evaluateTransform();
 669     m_contained.freezeTransform();
 670   }
 671   typedef MemberCaller<Doom3GroupInstance, &Doom3GroupInstance::applyTransform> ApplyTransformCaller;
 672
 673   void selectionChangedComponent(const Selectable& selectable)
 674   {
 675     GlobalSelectionSystem().getObserver(SelectionSystem::eComponent)(selectable);
 676     GlobalSelectionSystem().onComponentSelection(*this, selectable);
 677   }
 678   typedef MemberCaller1<Doom3GroupInstance, const Selectable&, &Doom3GroupInstance::selectionChangedComponent> SelectionChangedComponentCaller;
 679 };
 680
 681 class Doom3GroupNode :
 682   public scene::Node::Symbiot,
 683   public scene::Instantiable,
 684   public scene::Cloneable,
 685   public scene::Traversable::Observer
 686 {
 687   class TypeCasts
 688   {
 689     NodeTypeCastTable m_casts;
 690   public:
 691     TypeCasts()
 692     {
 693       NodeStaticCast<Doom3GroupNode, scene::Instantiable>::install(m_casts);
 694       NodeStaticCast<Doom3GroupNode, scene::Cloneable>::install(m_casts);
 695       NodeContainedCast<Doom3GroupNode, scene::Traversable>::install(m_casts);
 696       NodeContainedCast<Doom3GroupNode, Snappable>::install(m_casts);
 697       NodeContainedCast<Doom3GroupNode, TransformNode>::install(m_casts);
 698       NodeContainedCast<Doom3GroupNode, Entity>::install(m_casts);
 699       NodeContainedCast<Doom3GroupNode, Nameable>::install(m_casts);
 700       NodeContainedCast<Doom3GroupNode, Namespaced>::install(m_casts);
 701       NodeContainedCast<Doom3GroupNode, ModelSkin>::install(m_casts);
 702     }
 703     NodeTypeCastTable& get()
 704     {
 705       return m_casts;
 706     }
 707   };
 708
 709
 710   scene::Node m_node;
 711   InstanceSet m_instances;
 712   Doom3Group m_contained;
 713
 714   void construct()
 715   {
 716     m_contained.attach(this);
 717   }
 718   void destroy()
 719   {
 720     m_contained.detach(this);
 721   }
 722 public:
 723
 724   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 725
 726   scene::Traversable& get(NullType<scene::Traversable>)
 727   {
 728     return m_contained.getTraversable();
 729   }
 730   Snappable& get(NullType<Snappable>)
 731   {
 732     return m_contained;
 733   }
 734   TransformNode& get(NullType<TransformNode>)
 735   {
 736     return m_contained.getTransformNode();
 737   }
 738   Entity& get(NullType<Entity>)
 739   {
 740     return m_contained.getEntity();
 741   }
 742   Nameable& get(NullType<Nameable>)
 743   {
 744     return m_contained.getNameable();
 745   }
 746   Namespaced& get(NullType<Namespaced>)
 747   {
 748     return m_contained.getNamespaced();
 749   }
 750   ModelSkin& get(NullType<ModelSkin>)
 751   {
 752     return m_contained.getModelSkin();
 753   }
 754
 755   Doom3GroupNode(EntityClass* eclass) :
 756     m_node(this, this, StaticTypeCasts::instance().get()),
 757       m_contained(eclass, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSet::BoundsChangedCaller(m_instances), InstanceSetEvaluateTransform<Doom3GroupInstance>::Caller(m_instances))
 758   {
 759     construct();
 760   }
 761   Doom3GroupNode(const Doom3GroupNode& other) :
 762     scene::Node::Symbiot(other),
 763     scene::Instantiable(other),
 764     scene::Cloneable(other),
 765     scene::Traversable::Observer(other),
 766     m_node(this, this, StaticTypeCasts::instance().get()),
 767     m_contained(other.m_contained, m_node, InstanceSet::TransformChangedCaller(m_instances), InstanceSet::BoundsChangedCaller(m_instances), InstanceSetEvaluateTransform<Doom3GroupInstance>::Caller(m_instances))
 768   {
 769     construct();
 770   }
 771   ~Doom3GroupNode()
 772   {
 773     destroy();
 774   }
 775
 776   void release()
 777   {
 778     delete this;
 779   }
 780   scene::Node& node()
 781   {
 782     return m_node;
 783   }
 784
 785   scene::Node& clone() const
 786   {
 787     return (new Doom3GroupNode(*this))->node();
 788   }
 789
 790   void insert(scene::Node& child)
 791   {
 792     m_instances.insert(child);
 793   }
 794   void erase(scene::Node& child)
 795   {
 796     m_instances.erase(child);
 797   }
 798
 799   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
 800   {
 801     return new Doom3GroupInstance(path, parent, m_contained);
 802   }
 803   void forEachInstance(const scene::Instantiable::Visitor& visitor)
 804   {
 805     m_instances.forEachInstance(visitor);
 806   }
 807   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
 808   {
 809     m_instances.insert(observer, path, instance);
 810   }
 811   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
 812   {
 813     return m_instances.erase(observer, path);
 814   }
 815 };
 816
 817 void Doom3Group_construct()
 818 {
 819   CurveEdit::Type::instance().m_controlsShader = GlobalShaderCache().capture("$POINT");
 820   CurveEdit::Type::instance().m_selectedShader = GlobalShaderCache().capture("$SELPOINT");
 821 }
 822
 823 void Doom3Group_destroy()
 824 {
 825   GlobalShaderCache().release("$SELPOINT");
 826   GlobalShaderCache().release("$POINT");
 827 }
 828
 829 scene::Node& New_Doom3Group(EntityClass* eclass)
 830 {
 831   return (new Doom3GroupNode(eclass))->node();
 832 }