libs/entitylib.h

   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 #if !defined (INCLUDED_ENTITYLIB_H)
  23 #define INCLUDED_ENTITYLIB_H
  24
  25 #include "ireference.h"
  26 #include "debugging/debugging.h"
  27
  28 #include "ientity.h"
  29 #include "irender.h"
  30 #include "igl.h"
  31 #include "selectable.h"
  32
  33 #include "generic/callback.h"
  34 #include "math/vector.h"
  35 #include "math/aabb.h"
  36 #include "undolib.h"
  37 #include "string/pooledstring.h"
  38 #include "generic/referencecounted.h"
  39 #include "scenelib.h"
  40 #include "container/container.h"
  41 #include "eclasslib.h"
  42
  43 #include <list>
  44 #include <set>
  45
  46 inline void arrow_draw(const Vector3& origin, const Vector3& direction_forward, const Vector3& direction_left, const Vector3& direction_up)
  47 {
  48         Vector3 endpoint(vector3_added(origin, vector3_scaled(direction_forward, 32.0)));
  49
  50   Vector3 tip1(vector3_added(vector3_added(endpoint, vector3_scaled(direction_forward, -8.0)), vector3_scaled(direction_up, -4.0)));
  51         Vector3 tip2(vector3_added(tip1, vector3_scaled(direction_up, 8.0)));
  52   Vector3 tip3(vector3_added(vector3_added(endpoint, vector3_scaled(direction_forward, -8.0)), vector3_scaled(direction_left, -4.0)));
  53         Vector3 tip4(vector3_added(tip3, vector3_scaled(direction_left, 8.0)));
  54
  55   glBegin (GL_LINES);
  56
  57   glVertex3fv(vector3_to_array(origin));
  58   glVertex3fv(vector3_to_array(endpoint));
  59
  60   glVertex3fv(vector3_to_array(endpoint));
  61   glVertex3fv(vector3_to_array(tip1));
  62
  63   glVertex3fv(vector3_to_array(endpoint));
  64   glVertex3fv(vector3_to_array(tip2));
  65
  66   glVertex3fv(vector3_to_array(endpoint));
  67   glVertex3fv(vector3_to_array(tip3));
  68
  69   glVertex3fv(vector3_to_array(endpoint));
  70   glVertex3fv(vector3_to_array(tip4));
  71
  72   glVertex3fv(vector3_to_array(tip1));
  73   glVertex3fv(vector3_to_array(tip3));
  74
  75   glVertex3fv(vector3_to_array(tip3));
  76   glVertex3fv(vector3_to_array(tip2));
  77
  78   glVertex3fv(vector3_to_array(tip2));
  79   glVertex3fv(vector3_to_array(tip4));
  80
  81   glVertex3fv(vector3_to_array(tip4));
  82   glVertex3fv(vector3_to_array(tip1));
  83
  84   glEnd();
  85 }
  86
  87 class SelectionIntersection;
  88
  89 inline void aabb_testselect(const AABB& aabb, SelectionTest& test, SelectionIntersection& best)
  90 {
  91   const IndexPointer::index_type indices[24] = {
  92     2, 1, 5, 6,
  93     1, 0, 4, 5,
  94     0, 1, 2, 3,
  95     3, 7, 4, 0,
  96     3, 2, 6, 7,
  97     7, 6, 5, 4,
  98   };
  99
 100   Vector3 points[8];
 101   aabb_corners(aabb, points);
 102   test.TestQuads(VertexPointer(reinterpret_cast<VertexPointer::pointer>(points), sizeof(Vector3)), IndexPointer(indices, 24), best);
 103 }
 104
 105 inline void aabb_draw_wire(const Vector3 points[8])
 106 {
 107   unsigned int indices[24] = {
 108     0, 1, 1, 2, 2, 3, 3, 0,
 109     4, 5, 5, 6, 6, 7, 7, 4,
 110     0, 4, 1, 5, 2, 6, 3, 7,
 111   };
 112 #if 1
 113   glVertexPointer(3, GL_FLOAT, 0, points);
 114   glDrawElements(GL_LINES, sizeof(indices)/sizeof(indices[0]), GL_UNSIGNED_INT, indices);
 115 #else
 116   glBegin(GL_LINES);
 117   for(std::size_t i = 0; i < sizeof(indices)/sizeof(indices[0]); ++i)
 118   {
 119     glVertex3fv(points[indices[i]]);
 120   }
 121   glEnd();
 122 #endif
 123 }
 124
 125 inline void aabb_draw_flatshade(const Vector3 points[8])
 126 {
 127   glBegin(GL_QUADS);
 128
 129   glNormal3fv(vector3_to_array(aabb_normals[0]));
 130   glVertex3fv(vector3_to_array(points[2]));
 131   glVertex3fv(vector3_to_array(points[1]));
 132   glVertex3fv(vector3_to_array(points[5]));
 133   glVertex3fv(vector3_to_array(points[6]));
 134
 135   glNormal3fv(vector3_to_array(aabb_normals[1]));
 136   glVertex3fv(vector3_to_array(points[1]));
 137   glVertex3fv(vector3_to_array(points[0]));
 138   glVertex3fv(vector3_to_array(points[4]));
 139   glVertex3fv(vector3_to_array(points[5]));
 140
 141   glNormal3fv(vector3_to_array(aabb_normals[2]));
 142   glVertex3fv(vector3_to_array(points[0]));
 143   glVertex3fv(vector3_to_array(points[1]));
 144   glVertex3fv(vector3_to_array(points[2]));
 145   glVertex3fv(vector3_to_array(points[3]));
 146
 147   glNormal3fv(vector3_to_array(aabb_normals[3]));
 148   glVertex3fv(vector3_to_array(points[0]));
 149   glVertex3fv(vector3_to_array(points[3]));
 150   glVertex3fv(vector3_to_array(points[7]));
 151   glVertex3fv(vector3_to_array(points[4]));
 152
 153   glNormal3fv(vector3_to_array(aabb_normals[4]));
 154   glVertex3fv(vector3_to_array(points[3]));
 155   glVertex3fv(vector3_to_array(points[2]));
 156   glVertex3fv(vector3_to_array(points[6]));
 157   glVertex3fv(vector3_to_array(points[7]));
 158
 159   glNormal3fv(vector3_to_array(aabb_normals[5]));
 160   glVertex3fv(vector3_to_array(points[7]));
 161   glVertex3fv(vector3_to_array(points[6]));
 162   glVertex3fv(vector3_to_array(points[5]));
 163   glVertex3fv(vector3_to_array(points[4]));
 164
 165   glEnd();
 166 }
 167
 168 inline void aabb_draw_wire(const AABB& aabb)
 169 {
 170   Vector3 points[8];
 171         aabb_corners(aabb, points);
 172   aabb_draw_wire(points);
 173 }
 174
 175 inline void aabb_draw_flatshade(const AABB& aabb)
 176 {
 177   Vector3 points[8];
 178         aabb_corners(aabb, points);
 179   aabb_draw_flatshade(points);
 180 }
 181
 182 inline void aabb_draw_textured(const AABB& aabb)
 183 {
 184   Vector3 points[8];
 185         aabb_corners(aabb, points);
 186
 187   glBegin(GL_QUADS);
 188
 189   glNormal3fv(vector3_to_array(aabb_normals[0]));
 190   glTexCoord2fv(aabb_texcoord_topleft);
 191   glVertex3fv(vector3_to_array(points[2]));
 192   glTexCoord2fv(aabb_texcoord_topright);
 193   glVertex3fv(vector3_to_array(points[1]));
 194   glTexCoord2fv(aabb_texcoord_botright);
 195   glVertex3fv(vector3_to_array(points[5]));
 196   glTexCoord2fv(aabb_texcoord_botleft);
 197   glVertex3fv(vector3_to_array(points[6]));
 198
 199   glNormal3fv(vector3_to_array(aabb_normals[1]));
 200   glTexCoord2fv(aabb_texcoord_topleft);
 201   glVertex3fv(vector3_to_array(points[1]));
 202   glTexCoord2fv(aabb_texcoord_topright);
 203   glVertex3fv(vector3_to_array(points[0]));
 204   glTexCoord2fv(aabb_texcoord_botright);
 205   glVertex3fv(vector3_to_array(points[4]));
 206   glTexCoord2fv(aabb_texcoord_botleft);
 207   glVertex3fv(vector3_to_array(points[5]));
 208
 209   glNormal3fv(vector3_to_array(aabb_normals[2]));
 210   glTexCoord2fv(aabb_texcoord_topleft);
 211   glVertex3fv(vector3_to_array(points[0]));
 212   glTexCoord2fv(aabb_texcoord_topright);
 213   glVertex3fv(vector3_to_array(points[1]));
 214   glTexCoord2fv(aabb_texcoord_botright);
 215   glVertex3fv(vector3_to_array(points[2]));
 216   glTexCoord2fv(aabb_texcoord_botleft);
 217   glVertex3fv(vector3_to_array(points[3]));
 218
 219   glNormal3fv(vector3_to_array(aabb_normals[3]));
 220   glTexCoord2fv(aabb_texcoord_topleft);
 221   glVertex3fv(vector3_to_array(points[0]));
 222   glTexCoord2fv(aabb_texcoord_topright);
 223   glVertex3fv(vector3_to_array(points[3]));
 224   glTexCoord2fv(aabb_texcoord_botright);
 225   glVertex3fv(vector3_to_array(points[7]));
 226   glTexCoord2fv(aabb_texcoord_botleft);
 227   glVertex3fv(vector3_to_array(points[4]));
 228
 229   glNormal3fv(vector3_to_array(aabb_normals[4]));
 230   glTexCoord2fv(aabb_texcoord_topleft);
 231   glVertex3fv(vector3_to_array(points[3]));
 232   glTexCoord2fv(aabb_texcoord_topright);
 233   glVertex3fv(vector3_to_array(points[2]));
 234   glTexCoord2fv(aabb_texcoord_botright);
 235   glVertex3fv(vector3_to_array(points[6]));
 236   glTexCoord2fv(aabb_texcoord_botleft);
 237   glVertex3fv(vector3_to_array(points[7]));
 238
 239   glNormal3fv(vector3_to_array(aabb_normals[5]));
 240   glTexCoord2fv(aabb_texcoord_topleft);
 241   glVertex3fv(vector3_to_array(points[7]));
 242   glTexCoord2fv(aabb_texcoord_topright);
 243   glVertex3fv(vector3_to_array(points[6]));
 244   glTexCoord2fv(aabb_texcoord_botright);
 245   glVertex3fv(vector3_to_array(points[5]));
 246   glTexCoord2fv(aabb_texcoord_botleft);
 247   glVertex3fv(vector3_to_array(points[4]));
 248
 249   glEnd();
 250 }
 251
 252 inline void aabb_draw_solid(const AABB& aabb, RenderStateFlags state)
 253 {
 254   if(state & RENDER_TEXTURE)
 255   {
 256     aabb_draw_textured(aabb);
 257   }
 258   else
 259   {
 260     aabb_draw_flatshade(aabb);
 261   }
 262 }
 263
 264 inline void aabb_draw(const AABB& aabb, RenderStateFlags state)
 265 {
 266   if(state & RENDER_FILL)
 267   {
 268     aabb_draw_solid(aabb, state);
 269   }
 270   else
 271   {
 272     aabb_draw_wire(aabb);
 273   }
 274 }
 275
 276 class RenderableSolidAABB : public OpenGLRenderable
 277 {
 278   const AABB& m_aabb;
 279 public:
 280   RenderableSolidAABB(const AABB& aabb) : m_aabb(aabb)
 281   {
 282   }
 283   void render(RenderStateFlags state) const
 284   {
 285     aabb_draw_solid(m_aabb, state);
 286   }
 287 };
 288
 289 class RenderableWireframeAABB : public OpenGLRenderable
 290 {
 291   const AABB& m_aabb;
 292 public:
 293   RenderableWireframeAABB(const AABB& aabb) : m_aabb(aabb)
 294   {
 295   }
 296   void render(RenderStateFlags state) const
 297   {
 298     aabb_draw_wire(m_aabb);
 299   }
 300 };
 301
 302
 303 /// \brief A key/value pair of strings.
 304 ///
 305 /// - Notifies observers when value changes - value changes to "" on destruction.
 306 /// - Provides undo support through the global undo system.
 307 class KeyValue : public EntityKeyValue
 308 {
 309   typedef UnsortedSet<KeyObserver> KeyObservers;
 310
 311   std::size_t m_refcount;
 312   KeyObservers m_observers;
 313   CopiedString m_string;
 314   const char* m_empty;
 315   ObservedUndoableObject<CopiedString> m_undo;
 316   static EntityCreator::KeyValueChangedFunc m_entityKeyValueChanged;
 317 public:
 318
 319   KeyValue(const char* string, const char* empty)
 320     : m_refcount(0), m_string(string), m_empty(empty), m_undo(m_string, UndoImportCaller(*this))
 321   {
 322     notify();
 323   }
 324   ~KeyValue()
 325   {
 326     ASSERT_MESSAGE(m_observers.empty(), "KeyValue::~KeyValue: observers still attached");
 327   }
 328
 329   static void setKeyValueChangedFunc(EntityCreator::KeyValueChangedFunc func)
 330   {
 331     m_entityKeyValueChanged = func;
 332   }
 333
 334   void IncRef()
 335   {
 336     ++m_refcount;
 337   }
 338   void DecRef()
 339   {
 340     if(--m_refcount == 0)
 341     {
 342       delete this;
 343     }
 344   }
 345
 346   void instanceAttach(MapFile* map)
 347   {
 348     m_undo.instanceAttach(map);
 349   }
 350   void instanceDetach(MapFile* map)
 351   {
 352     m_undo.instanceDetach(map);
 353   }
 354
 355   void attach(const KeyObserver& observer)
 356   {
 357     (*m_observers.insert(observer))(c_str());
 358   }
 359   void detach(const KeyObserver& observer)
 360   {
 361     observer(m_empty);
 362     m_observers.erase(observer);
 363   }
 364   const char* c_str() const
 365   {
 366     if(string_empty(m_string.c_str()))
 367     {
 368       return m_empty;
 369     }
 370     return m_string.c_str();
 371   }
 372   void assign(const char* other)
 373   {
 374     if(!string_equal(m_string.c_str(), other))
 375     {
 376       m_undo.save();
 377       m_string = other;
 378       notify();
 379     }
 380   }
 381
 382   void notify()
 383   {
 384     m_entityKeyValueChanged();
 385     KeyObservers::reverse_iterator i = m_observers.rbegin();
 386     while(i != m_observers.rend())
 387     {
 388       (*i++)(c_str());
 389     }
 390   }
 391
 392   void importState(const CopiedString& string)
 393   {
 394     m_string = string;
 395
 396     notify();
 397   }
 398   typedef MemberCaller1<KeyValue, const CopiedString&, &KeyValue::importState> UndoImportCaller;
 399 };
 400
 401 /// \brief An unsorted list of key/value pairs.
 402 ///
 403 /// - Notifies observers when a pair is inserted or removed.
 404 /// - Provides undo support through the global undo system.
 405 /// - New keys are appended to the end of the list.
 406 class EntityKeyValues : public Entity
 407 {
 408 public:
 409   typedef KeyValue Value;
 410
 411   static StringPool& getPool()
 412   {
 413     return Static<StringPool, KeyContext>::instance();
 414   }
 415 private:
 416   static EntityCreator::KeyValueChangedFunc m_entityKeyValueChanged;
 417   static Counter* m_counter;
 418
 419   EntityClass* m_eclass;
 420
 421   class KeyContext{};
 422   typedef Static<StringPool, KeyContext> KeyPool;
 423   typedef PooledString<KeyPool> Key;
 424   typedef SmartPointer<KeyValue> KeyValuePtr;
 425   typedef UnsortedMap<Key, KeyValuePtr> KeyValues;
 426   KeyValues m_keyValues;
 427
 428   typedef UnsortedSet<Observer*> Observers;
 429   Observers m_observers;
 430
 431   ObservedUndoableObject<KeyValues> m_undo;
 432   bool m_instanced;
 433
 434   bool m_observerMutex;
 435
 436   void notifyInsert(const char* key, Value& value)
 437   {
 438     m_observerMutex = true;
 439     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
 440     {
 441       (*i)->insert(key, value);
 442     }
 443     m_observerMutex = false;
 444   }
 445   void notifyErase(const char* key, Value& value)
 446   {
 447     m_observerMutex = true;
 448     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
 449     {
 450       (*i)->erase(key, value);
 451     }
 452     m_observerMutex = false;
 453   }
 454   void forEachKeyValue_notifyInsert()
 455   {
 456     for(KeyValues::const_iterator i = m_keyValues.begin(); i != m_keyValues.end(); ++i)
 457     {
 458       notifyInsert((*i).first.c_str(), *(*i).second);
 459     }
 460   }
 461   void forEachKeyValue_notifyErase()
 462   {
 463     for(KeyValues::const_iterator i = m_keyValues.begin(); i != m_keyValues.end(); ++i)
 464     {
 465       notifyErase((*i).first.c_str(), *(*i).second);
 466     }
 467   }
 468
 469   void insert(const char* key, const KeyValuePtr& keyValue)
 470   {
 471     KeyValues::iterator i = m_keyValues.insert(KeyValues::value_type(key, keyValue));
 472     notifyInsert(key, *(*i).second);
 473
 474     if(m_instanced)
 475     {
 476       (*i).second->instanceAttach(m_undo.map());
 477     }
 478   }
 479
 480   void insert(const char* key, const char* value)
 481   {
 482     KeyValues::iterator i = m_keyValues.find(key);
 483     if(i != m_keyValues.end())
 484     {
 485       (*i).second->assign(value);
 486     }
 487     else
 488     {
 489       m_undo.save();
 490       insert(key, KeyValuePtr(new KeyValue(value, EntityClass_valueForKey(*m_eclass, key))));
 491     }
 492   }
 493
 494   void erase(KeyValues::iterator i)
 495   {
 496     if(m_instanced)
 497     {
 498       (*i).second->instanceDetach(m_undo.map());
 499     }
 500
 501     Key key((*i).first);
 502     KeyValuePtr value((*i).second);
 503     m_keyValues.erase(i);
 504     notifyErase(key.c_str(), *value);
 505   }
 506
 507   void erase(const char* key)
 508   {
 509     KeyValues::iterator i = m_keyValues.find(key);
 510     if(i != m_keyValues.end())
 511     {
 512       m_undo.save();
 513       erase(i);
 514     }
 515   }
 516
 517 public:
 518   bool m_isContainer;
 519
 520   EntityKeyValues(EntityClass* eclass) :
 521     m_eclass(eclass),
 522     m_undo(m_keyValues, UndoImportCaller(*this)),
 523     m_instanced(false),
 524     m_observerMutex(false),
 525     m_isContainer(!eclass->fixedsize)
 526   {
 527   }
 528   EntityKeyValues(const EntityKeyValues& other) :
 529     Entity(other),
 530     m_eclass(&other.getEntityClass()),
 531     m_undo(m_keyValues, UndoImportCaller(*this)),
 532     m_instanced(false),
 533     m_observerMutex(false),
 534     m_isContainer(other.m_isContainer)
 535   {
 536     for(KeyValues::const_iterator i = other.m_keyValues.begin(); i != other.m_keyValues.end(); ++i)
 537     {
 538       insert((*i).first.c_str(), (*i).second->c_str());
 539     }
 540   }
 541   ~EntityKeyValues()
 542   {
 543     for(Observers::iterator i = m_observers.begin(); i != m_observers.end();)
 544     {
 545       // post-increment to allow current element to be removed safely
 546       (*i++)->clear();
 547     }
 548     ASSERT_MESSAGE(m_observers.empty(), "EntityKeyValues::~EntityKeyValues: observers still attached");
 549   }
 550
 551   static void setKeyValueChangedFunc(EntityCreator::KeyValueChangedFunc func)
 552   {
 553     m_entityKeyValueChanged = func;
 554     KeyValue::setKeyValueChangedFunc(func);
 555   }
 556   static void setCounter(Counter* counter)
 557   {
 558     m_counter = counter;
 559   }
 560
 561   void importState(const KeyValues& keyValues)
 562   {
 563     for(KeyValues::iterator i = m_keyValues.begin(); i != m_keyValues.end();)
 564     {
 565       erase(i++);
 566     }
 567
 568     for(KeyValues::const_iterator i = keyValues.begin(); i != keyValues.end(); ++i)
 569     {
 570       insert((*i).first.c_str(), (*i).second);
 571     }
 572
 573     m_entityKeyValueChanged();
 574   }
 575   typedef MemberCaller1<EntityKeyValues, const KeyValues&, &EntityKeyValues::importState> UndoImportCaller;
 576
 577   void attach(Observer& observer)
 578   {
 579     ASSERT_MESSAGE(!m_observerMutex, "observer cannot be attached during iteration");
 580     m_observers.insert(&observer);
 581     for(KeyValues::const_iterator i = m_keyValues.begin(); i != m_keyValues.end(); ++i)
 582     {
 583       observer.insert((*i).first.c_str(), *(*i).second);
 584     }
 585   }
 586   void detach(Observer& observer)
 587   {
 588     ASSERT_MESSAGE(!m_observerMutex, "observer cannot be detached during iteration");
 589     m_observers.erase(&observer);
 590     for(KeyValues::const_iterator i = m_keyValues.begin(); i != m_keyValues.end(); ++i)
 591     {
 592       observer.erase((*i).first.c_str(), *(*i).second);
 593     }
 594   }
 595
 596   void forEachKeyValue_instanceAttach(MapFile* map)
 597   {
 598     for(KeyValues::const_iterator i = m_keyValues.begin(); i != m_keyValues.end(); ++i)
 599     {
 600       (*i).second->instanceAttach(map);
 601     }
 602   }
 603   void forEachKeyValue_instanceDetach(MapFile* map)
 604   {
 605     for(KeyValues::const_iterator i = m_keyValues.begin(); i != m_keyValues.end(); ++i)
 606     {
 607       (*i).second->instanceDetach(map);
 608     }
 609   }
 610
 611   void instanceAttach(MapFile* map)
 612   {
 613     if(m_counter != 0)
 614     {
 615       m_counter->increment();
 616     }
 617
 618     m_instanced = true;
 619     forEachKeyValue_instanceAttach(map);
 620     m_undo.instanceAttach(map);
 621   }
 622   void instanceDetach(MapFile* map)
 623   {
 624     if(m_counter != 0)
 625     {
 626       m_counter->decrement();
 627     }
 628
 629     m_undo.instanceDetach(map);
 630     forEachKeyValue_instanceDetach(map);
 631     m_instanced = false;
 632   }
 633
 634   // entity
 635   EntityClass& getEntityClass() const
 636   {
 637     return *m_eclass;
 638   }
 639   void forEachKeyValue(Visitor& visitor) const
 640   {
 641     for(KeyValues::const_iterator i = m_keyValues.begin(); i != m_keyValues.end(); ++i)
 642     {
 643       visitor.visit((*i).first.c_str(), (*i).second->c_str());
 644     }
 645   }
 646   void setKeyValue(const char* key, const char* value)
 647   {
 648     if(value[0] == '\0'
 649       /*|| string_equal(EntityClass_valueForKey(*m_eclass, key), value)*/) // don't delete values equal to default
 650     {
 651       erase(key);
 652     }
 653     else
 654     {
 655       insert(key, value);
 656     }
 657     m_entityKeyValueChanged();
 658   }
 659   const char* getKeyValue(const char* key) const
 660   {
 661     KeyValues::const_iterator i = m_keyValues.find(key);
 662     if(i != m_keyValues.end())
 663     {
 664       return (*i).second->c_str();
 665     }
 666
 667     return EntityClass_valueForKey(*m_eclass, key);
 668   }
 669
 670   bool isContainer() const
 671   {
 672     return m_isContainer;
 673   }
 674 };
 675
 676 /// \brief A Resource reference with a controlled lifetime.
 677 /// \brief The resource is released when the ResourceReference is destroyed.
 678 class ResourceReference
 679 {
 680   CopiedString m_name;
 681   Resource* m_resource;
 682 public:
 683   ResourceReference(const char* name)
 684     : m_name(name)
 685   {
 686     capture();
 687   }
 688   ResourceReference(const ResourceReference& other)
 689     : m_name(other.m_name)
 690   {
 691     capture();
 692   }
 693   ResourceReference& operator=(const ResourceReference& other)
 694   {
 695     ResourceReference tmp(other);
 696     tmp.swap(*this);
 697     return *this;
 698   }
 699   ~ResourceReference()
 700   {
 701     release();
 702   }
 703
 704   void capture()
 705   {
 706     m_resource = GlobalReferenceCache().capture(m_name.c_str());
 707   }
 708   void release()
 709   {
 710     GlobalReferenceCache().release(m_name.c_str());
 711   }
 712
 713   const char* getName() const
 714   {
 715     return m_name.c_str();
 716   }
 717   void setName(const char* name)
 718   {
 719     ResourceReference tmp(name);
 720     tmp.swap(*this);
 721   }
 722
 723   void swap(ResourceReference& other)
 724   {
 725     std::swap(m_resource, other.m_resource);
 726     std::swap(m_name, other.m_name);
 727   }
 728
 729   void attach(ModuleObserver& observer)
 730   {
 731     m_resource->attach(observer);
 732   }
 733   void detach(ModuleObserver& observer)
 734   {
 735     m_resource->detach(observer);
 736   }
 737
 738   Resource* get()
 739   {
 740     return m_resource;
 741   }
 742 };
 743
 744 namespace std
 745 {
 746   /// \brief Swaps the values of \p self and \p other.
 747   /// Overloads std::swap.
 748   inline void swap(ResourceReference& self, ResourceReference& other)
 749   {
 750     self.swap(other);
 751   }
 752 }
 753
 754 #endif