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