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