plugins/entity/group.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 does not have a fixed size specified in its entity-definition (except misc_model).
  24 ///
  25 /// This entity behaves as a group, i.e. it contains brushes.
  26
  27 #include "cullable.h"
  28 #include "renderable.h"
  29 #include "editable.h"
  30
  31 #include "selectionlib.h"
  32 #include "instancelib.h"
  33 #include "transformlib.h"
  34 #include "traverselib.h"
  35 #include "entitylib.h"
  36 #include "render.h"
  37 #include "eclasslib.h"
  38
  39 #include "targetable.h"
  40 #include "origin.h"
  41 #include "angles.h"
  42 #include "scale.h"
  43 #include "filters.h"
  44 #include "namedentity.h"
  45 #include "keyobservers.h"
  46 #include "namekeys.h"
  47
  48 #include "entity.h"
  49
  50 class Group
  51 {
  52   EntityKeyValues m_entity;
  53   KeyObserverMap m_keyObservers;
  54   MatrixTransform m_transform;
  55   TraversableNodeSet m_traverse;
  56
  57   ClassnameFilter m_filter;
  58   NamedEntity m_named;
  59   NameKeys m_nameKeys;
  60
  61   RenderableNamedEntity m_renderName;
  62
  63   Callback m_transformChanged;
  64
  65   void construct()
  66   {
  67     m_keyObservers.insert("classname", ClassnameFilter::ClassnameChangedCaller(m_filter));
  68     m_keyObservers.insert(Static<KeyIsName>::instance().m_nameKey, NamedEntity::IdentifierChangedCaller(m_named));
  69   }
  70
  71 public:
  72   Group(EntityClass* eclass, scene::Node& node, const Callback& transformChanged) :
  73     m_entity(eclass),
  74     m_filter(m_entity, node),
  75     m_named(m_entity),
  76     m_nameKeys(m_entity),
  77     m_renderName(m_named, g_vector3_identity),
  78     m_transformChanged(transformChanged)
  79   {
  80     construct();
  81   }
  82   Group(const Group& other, scene::Node& node, const Callback& transformChanged) :
  83     m_entity(other.m_entity),
  84     m_filter(m_entity, node),
  85     m_named(m_entity),
  86     m_nameKeys(m_entity),
  87     m_renderName(m_named, g_vector3_identity),
  88     m_transformChanged(transformChanged)
  89   {
  90     construct();
  91   }
  92
  93   InstanceCounter m_instanceCounter;
  94   void instanceAttach(const scene::Path& path)
  95   {
  96     if(++m_instanceCounter.m_count == 1)
  97     {
  98       m_filter.instanceAttach();
  99       m_entity.instanceAttach(path_find_mapfile(path.begin(), path.end()));
 100       m_traverse.instanceAttach(path_find_mapfile(path.begin(), path.end()));
 101       m_entity.attach(m_keyObservers);
 102     }
 103   }
 104   void instanceDetach(const scene::Path& path)
 105   {
 106     if(--m_instanceCounter.m_count == 0)
 107     {
 108       m_entity.detach(m_keyObservers);
 109       m_traverse.instanceDetach(path_find_mapfile(path.begin(), path.end()));
 110       m_entity.instanceDetach(path_find_mapfile(path.begin(), path.end()));
 111       m_filter.instanceDetach();
 112     }
 113   }
 114
 115   EntityKeyValues& getEntity()
 116   {
 117     return m_entity;
 118   }
 119   const EntityKeyValues& getEntity() const
 120   {
 121     return m_entity;
 122   }
 123
 124   scene::Traversable& getTraversable()
 125   {
 126     return m_traverse;
 127   }
 128   Namespaced& getNamespaced()
 129   {
 130     return m_nameKeys;
 131   }
 132   Nameable& getNameable()
 133   {
 134     return m_named;
 135   }
 136   TransformNode& getTransformNode()
 137   {
 138     return m_transform;
 139   }
 140
 141   void attach(scene::Traversable::Observer* observer)
 142   {
 143     m_traverse.attach(observer);
 144   }
 145   void detach(scene::Traversable::Observer* observer)
 146   {
 147     m_traverse.detach(observer);
 148   }
 149
 150   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
 151   {
 152     renderer.SetState(m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly);
 153   }
 154   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
 155   {
 156     renderSolid(renderer, volume, localToWorld);
 157
 158     if(g_showNames)
 159     {
 160       renderer.addRenderable(m_renderName, m_transform.localToParent());
 161     }
 162   }
 163 };
 164
 165 #if 0
 166 class TransformableSetTranslation
 167 {
 168   Translation m_value;
 169 public:
 170   TransformableSetTranslation(const Translation& value) : m_value(value)
 171   {
 172   }
 173   void operator()(Transformable& transformable) const
 174   {
 175     transformable.setTranslation(m_value);
 176   }
 177 };
 178
 179 class TransformableSetRotation
 180 {
 181   Rotation m_value;
 182 public:
 183   TransformableSetRotation(const Rotation& value) : m_value(value)
 184   {
 185   }
 186   void operator()(Transformable& transformable) const
 187   {
 188     transformable.setRotation(m_value);
 189   }
 190 };
 191
 192 class TransformableSetScale
 193 {
 194   Scale m_value;
 195 public:
 196   TransformableSetScale(const Scale& value) : m_value(value)
 197   {
 198   }
 199   void operator()(Transformable& transformable) const
 200   {
 201     transformable.setScale(m_value);
 202   }
 203 };
 204
 205 class TransformableSetType
 206 {
 207   TransformModifierType m_value;
 208 public:
 209   TransformableSetType(const TransformModifierType& value) : m_value(value)
 210   {
 211   }
 212   void operator()(Transformable& transformable) const
 213   {
 214     transformable.setType(m_value);
 215   }
 216 };
 217
 218 class TransformableFreezeTransform
 219 {
 220   TransformModifierType m_value;
 221 public:
 222   void operator()(Transformable& transformable) const
 223   {
 224     transformable.freezeTransform();
 225   }
 226 };
 227
 228 template<typename Functor>
 229 inline void Scene_forEachChildTransformable(const Functor& functor, const scene::Path& path)
 230 {
 231   GlobalSceneGraph().traverse_subgraph(ChildInstanceWalker< InstanceApply<Transformable, Functor> >(functor), path);
 232 }
 233 #endif
 234
 235 class GroupInstance :
 236   public TargetableInstance,
 237 #if 0
 238   public Transformable,
 239 #endif
 240   public Renderable
 241 {
 242   class TypeCasts
 243   {
 244     InstanceTypeCastTable m_casts;
 245   public:
 246     TypeCasts()
 247     {
 248       m_casts = TargetableInstance::StaticTypeCasts::instance().get();
 249       InstanceStaticCast<GroupInstance, Renderable>::install(m_casts);
 250 #if 0
 251       InstanceStaticCast<GroupInstance, Transformable>::install(m_casts);
 252 #endif
 253     }
 254     InstanceTypeCastTable& get()
 255     {
 256       return m_casts;
 257     }
 258   };
 259
 260   Group& m_contained;
 261 public:
 262   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 263
 264   GroupInstance(const scene::Path& path, scene::Instance* parent, Group& group) :
 265     TargetableInstance(path, parent, this, StaticTypeCasts::instance().get(), group.getEntity(), *this),
 266     m_contained(group)
 267   {
 268     m_contained.instanceAttach(Instance::path());
 269     StaticRenderableConnectionLines::instance().attach(*this);
 270   }
 271   ~GroupInstance()
 272   {
 273     StaticRenderableConnectionLines::instance().detach(*this);
 274     m_contained.instanceDetach(Instance::path());
 275   }
 276   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
 277   {
 278     m_contained.renderSolid(renderer, volume, Instance::localToWorld());
 279   }
 280   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
 281   {
 282     m_contained.renderWireframe(renderer, volume, Instance::localToWorld());
 283   }
 284
 285 #if 0
 286   void setType(TransformModifierType type)
 287   {
 288     Scene_forEachChildTransformable(TransformableSetType(type), Instance::path());
 289   }
 290   void setTranslation(const Translation& value)
 291   {
 292     Scene_forEachChildTransformable(TransformableSetTranslation(value), Instance::path());
 293   }
 294   void setRotation(const Rotation& value)
 295   {
 296     Scene_forEachChildTransformable(TransformableSetRotation(value), Instance::path());
 297   }
 298   void setScale(const Scale& value)
 299   {
 300     Scene_forEachChildTransformable(TransformableSetScale(value), Instance::path());
 301   }
 302   void freezeTransform()
 303   {
 304     Scene_forEachChildTransformable(TransformableFreezeTransform(), Instance::path());
 305   }
 306
 307   void evaluateTransform()
 308   {
 309   }
 310 #endif
 311 };
 312
 313 class GroupNode :
 314   public scene::Node::Symbiot,
 315   public scene::Instantiable,
 316   public scene::Cloneable,
 317   public scene::Traversable::Observer
 318 {
 319   class TypeCasts
 320   {
 321     NodeTypeCastTable m_casts;
 322   public:
 323     TypeCasts()
 324     {
 325       NodeStaticCast<GroupNode, scene::Instantiable>::install(m_casts);
 326       NodeStaticCast<GroupNode, scene::Cloneable>::install(m_casts);
 327       NodeContainedCast<GroupNode, scene::Traversable>::install(m_casts);
 328       NodeContainedCast<GroupNode, TransformNode>::install(m_casts);
 329       NodeContainedCast<GroupNode, Entity>::install(m_casts);
 330       NodeContainedCast<GroupNode, Nameable>::install(m_casts);
 331       NodeContainedCast<GroupNode, Namespaced>::install(m_casts);
 332     }
 333     NodeTypeCastTable& get()
 334     {
 335       return m_casts;
 336     }
 337   };
 338
 339
 340   scene::Node m_node;
 341   InstanceSet m_instances;
 342   Group m_contained;
 343
 344   void construct()
 345   {
 346     m_contained.attach(this);
 347   }
 348   void destroy()
 349   {
 350     m_contained.detach(this);
 351   }
 352
 353 public:
 354
 355   typedef LazyStatic<TypeCasts> StaticTypeCasts;
 356
 357   scene::Traversable& get(NullType<scene::Traversable>)
 358   {
 359     return m_contained.getTraversable();
 360   }
 361   TransformNode& get(NullType<TransformNode>)
 362   {
 363     return m_contained.getTransformNode();
 364   }
 365   Entity& get(NullType<Entity>)
 366   {
 367     return m_contained.getEntity();
 368   }
 369   Nameable& get(NullType<Nameable>)
 370   {
 371     return m_contained.getNameable();
 372   }
 373   Namespaced& get(NullType<Namespaced>)
 374   {
 375     return m_contained.getNamespaced();
 376   }
 377
 378   GroupNode(EntityClass* eclass) :
 379     m_node(this, this, StaticTypeCasts::instance().get()),
 380     m_contained(eclass, m_node, InstanceSet::TransformChangedCaller(m_instances))
 381   {
 382     construct();
 383   }
 384   GroupNode(const GroupNode& other) :
 385     scene::Node::Symbiot(other),
 386     scene::Instantiable(other),
 387     scene::Cloneable(other),
 388     scene::Traversable::Observer(other),
 389     m_node(this, this, StaticTypeCasts::instance().get()),
 390     m_contained(other.m_contained, m_node, InstanceSet::TransformChangedCaller(m_instances))
 391   {
 392     construct();
 393   }
 394   ~GroupNode()
 395   {
 396     destroy();
 397   }
 398
 399   void release()
 400   {
 401     delete this;
 402   }
 403   scene::Node& node()
 404   {
 405     return m_node;
 406   }
 407
 408   scene::Node& clone() const
 409   {
 410     return (new GroupNode(*this))->node();
 411   }
 412
 413   void insert(scene::Node& child)
 414   {
 415     m_instances.insert(child);
 416   }
 417   void erase(scene::Node& child)
 418   {
 419     m_instances.erase(child);
 420   }
 421
 422   scene::Instance* create(const scene::Path& path, scene::Instance* parent)
 423   {
 424     return new GroupInstance(path, parent, m_contained);
 425   }
 426   void forEachInstance(const scene::Instantiable::Visitor& visitor)
 427   {
 428     m_instances.forEachInstance(visitor);
 429   }
 430   void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
 431   {
 432     m_instances.insert(observer, path, instance);
 433   }
 434   scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
 435   {
 436     return m_instances.erase(observer, path);
 437   }
 438 };
 439
 440 scene::Node& New_Group(EntityClass* eclass)
 441 {
 442   return (new GroupNode(eclass))->node();
 443 }