Index: code/branches/core7/src/libraries/core/object/DestroyLaterManager.cc
===================================================================
--- code/branches/core7/src/libraries/core/object/DestroyLaterManager.cc	(revision 10544)
+++ code/branches/core7/src/libraries/core/object/DestroyLaterManager.cc	(revision 10555)
@@ -51,5 +51,5 @@
     void DestroyLaterManager::postUpdate(const Clock& time)
     {
-        // clearing the list will destroy all smartpointers and thus all retained instances (as long as there are no other smart pointers pointing to them).
+        // clearing the list will destroy all strong pointers and thus all retained instances (as long as there are no other strong pointers pointing to them).
         this->retainedInstances_.clear();
     }
Index: code/branches/core7/src/libraries/core/object/DestroyLaterManager.h
===================================================================
--- code/branches/core7/src/libraries/core/object/DestroyLaterManager.h	(revision 10544)
+++ code/branches/core7/src/libraries/core/object/DestroyLaterManager.h	(revision 10555)
@@ -34,5 +34,5 @@
 #include "util/Singleton.h"
 #include "core/UpdateListener.h"
-#include "SmartPtr.h"
+#include "StrongPtr.h"
 
 namespace orxonox
@@ -52,5 +52,5 @@
 
         private:
-            std::vector<SmartPtr<Destroyable> > retainedInstances_;
+            std::vector<StrongPtr<Destroyable> > retainedInstances_;
 
             static DestroyLaterManager* singletonPtr_s;
Index: code/branches/core7/src/libraries/core/object/Destroyable.cc
===================================================================
--- code/branches/core7/src/libraries/core/object/Destroyable.cc	(revision 10544)
+++ code/branches/core7/src/libraries/core/object/Destroyable.cc	(revision 10555)
@@ -61,6 +61,6 @@
 
     /**
-        @brief Deletes the object if no @ref orxonox::SmartPtr "smart pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
-        Always call destroy() instead of using 'delete' directly, otherwise smart pointers won't work.
+        @brief Deletes the object if no @ref orxonox::StrongPtr "strong pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
+        Always call destroy() instead of using 'delete' directly, otherwise strong pointers won't work.
     */
     void Destroyable::destroy()
@@ -81,8 +81,8 @@
     void Destroyable::destroyLater()
     {
-        // register in DestroyLaterManager - this ensures that a smartPtr points to this object and keeps it alive for a while
+        // register in DestroyLaterManager - this ensures that a strongPtr points to this object and keeps it alive for a while
         DestroyLaterManager::getInstance().retain(this);
 
-        // request destruction -> object will be deleted after all smartPtrs (including the one in DestroyLaterManager) were destroyed.
+        // request destruction -> object will be deleted after all strongPtrs (including the one in DestroyLaterManager) were destroyed.
         this->destroy();
     }
Index: code/branches/core7/src/libraries/core/object/Destroyable.h
===================================================================
--- code/branches/core7/src/libraries/core/object/Destroyable.h	(revision 10544)
+++ code/branches/core7/src/libraries/core/object/Destroyable.h	(revision 10555)
@@ -30,5 +30,5 @@
     @file
     @ingroup Object
-    @brief Declaration of Destroyable, the base class of all objects which can be used with SmartPtr and WeakPtr.
+    @brief Declaration of Destroyable, the base class of all objects which can be used with StrongPtr and WeakPtr.
 */
 
@@ -43,10 +43,10 @@
 {
     /**
-        @brief Classes must inherit from this class if they should be used with SmartPtr or WeakPtr.
+        @brief Classes must inherit from this class if they should be used with StrongPtr or WeakPtr.
     */
     class _CoreExport Destroyable
     {
         template <class T>
-        friend class SmartPtr;
+        friend class StrongPtr;
 
         friend class DestructionListener;
@@ -59,18 +59,18 @@
             void destroyLater();
 
-            /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
+            /// Returns the number of @ref orxonox::StrongPtr "strong pointers" that point to this object.
             inline unsigned int getReferenceCount() const
                 { return this->referenceCount_; }
 
         protected:
-            /// This virtual function is called if destroy() is called and no SmartPtr points to this object. Used in some cases to create a new SmartPtr to
+            /// This virtual function is called if destroy() is called and no StrongPtr points to this object. Used in some cases to create a new StrongPtr to
             /// prevent destruction. Don't call this function directly - use destroy() instead.
             virtual void preDestroy() {}
 
         private:
-            /// Increments the reference counter (for smart pointers).
+            /// Increments the reference counter (for strong pointers).
             inline void incrementReferenceCount()
                 { ++this->referenceCount_; }
-            /// Decrements the reference counter (for smart pointers).
+            /// Decrements the reference counter (for strong pointers).
             inline void decrementReferenceCount()
             {
@@ -87,5 +87,5 @@
                 { this->destructionListeners_.erase(pointer); }
 
-            int referenceCount_;                                    //!< Counts the references from smart pointers to this object
+            int referenceCount_;                                    //!< Counts the references from strong pointers to this object
             bool requestedDestruction_;                             //!< Becomes true after someone called delete on this object
             std::set<DestructionListener*> destructionListeners_;   //!< All destruction listeners (for example weak pointers which point to this object and like to get notified if it dies)
Index: code/branches/core7/src/libraries/core/object/SmartPtr.h
===================================================================
--- code/branches/core7/src/libraries/core/object/SmartPtr.h	(revision 10544)
+++ 	(revision )
@@ -1,304 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-// Inspired by boost::intrusive_ptr by Peter Dimov
-
-/**
-    @defgroup SmartPtr SmartPtr<T> and WeakPtr<T>
-    @ingroup Object
-*/
-
-/**
-    @file
-    @ingroup Object SmartPtr
-    @brief Definition of SmartPtr<T>, wraps a pointer to an object and keeps it alive.
-
-    @anchor SmartPtrExample
-
-    orxonox::SmartPtr is an implementation of a smart pointer - it wraps a pointer to an
-    object  and keeps this object alive until no SmartPtr points to this object anymore.
-    In contrast to orxonox::SharedPtr, SmartPtr works only with classes that are derived
-    from orxonox::Destroyable, because it's an intrusive implementation, meaning the
-    reference counter is stored in the object itself.
-
-    It's possible to use normal pointers and smart pointers to an object simultaneously.
-    You don't have to use SmartPtr all the time, you can create a SmartPtr for an object
-    at any time and also convert it back to a normal pointer if you like. This is possible
-    because the reference counter is stored in the object itself and not in SmartPtr (in
-    contrast to SharedPtr).
-
-    @b Important: If you want to delete an object, you must not use @c delete @c object but
-    rather @c object->destroy(). This function will check if there are smart pointers
-    pointing to the object. If yes, the object will be kept alive until all smart pointes
-    are destroyed. If no, the object is deleted instantly.
-
-    If all smart pointers that point to an object are destroyed, but you never called
-    @c object->destroy() before, the object will not be deleted! All a SmartPtr will do
-    is to really just keep an object alive, but it will not delete it automatically
-    unless you tried to destroy it before.
-
-    Example:
-    @code
-    class MyClass                                           // class declaration
-    {
-        public:
-            void setObject(OtherClass* object)              // passes a normal pointer which will be stored in a SmartPtr
-                { this->object_ = object; }
-
-            OtherClass* getObject() const                   // converts the SmartPtr to a normal pointer and returns it
-                { return this->object_; }
-
-        private:
-            SmartPtr<OtherClass> object_;                   // a pointer to an instance of OtherClass is stored in a SmartPtr
-    };
-    @endcode
-    In this example we assume that OtherClass is a child of Destroyable. We don't care
-    about the inheritance of MyClass though.
-
-    Now we create an instance of MyClass and assign a pointer to an instance of OtherClass:
-    @code
-    MyClass* myclass = new MyClass();                       // create an instance of MyClass
-    OtherClass* object = new OtherClass();                  // create an instance of OtherClass
-    myclass->setObject(object);                             // the object is now stored in a SmartPtr inside myclass
-
-    object->destroy();                                      // we try to destroy object, but there's still a SmartPtr pointing at it.
-
-    # object still exists at this point (because a SmartPtr points at it)
-
-    delete myclass;                                         // now we delete myclass, which also destroys the SmartPtr
-
-    # object doesn't exist anymore (because the SmartPtr is now destroyed)
-    @endcode
-
-    Now we look at the same example, but we first delete myclass, then destroy object:
-    @code
-    MyClass* myclass = new MyClass();                       // create an instance of MyClass
-    OtherClass* object = new OtherClass();                  // create an instance of OtherClass
-    myclass->setObject(object);                             // the object is now stored in a SmartPtr inside myclass
-
-    delete myclass;                                         // we delete myclass, which also destroys the SmartPtr
-
-    # object still exists at this point (because destroy() was not called yet)
-
-    object->destroy();                                      // now we try to destroy object, which works instantly
-
-    # object doesn't exist anymore (because we just destroyed it)
-    @endcode
-
-    Note that in any case @c object->destroy() has to be called to delete the object.
-    However if a SmartPtr points at it, the destruction is delayed until all SmartPtr
-    are destroyed.
-*/
-
-#ifndef _SmartPtr_H__
-#define _SmartPtr_H__
-
-#include "core/CorePrereqs.h"
-
-#include <cassert>
-
-#include "core/object/Destroyable.h"
-#include "WeakPtr.h"
-
-namespace orxonox
-{
-    /**
-        @brief A smart pointer which wraps a pointer to an object and keeps this object alive as long as the smart pointer exists.
-
-        @see See @ref SmartPtrExample "this description" for more information and an example.
-    */
-    template <class T>
-    class SmartPtr
-    {
-        public:
-            /// Constructor: Initializes the smart pointer with a null pointer.
-            inline SmartPtr() : pointer_(0), base_(0)
-            {
-            }
-
-            /// Constructor: Initializes the smart pointer with a pointer to an object. @param pointer The pointer @param bAddRef If true, the reference counter is increased. Don't set this to false unless you know exactly what you're doing! (for example to avoid circular references if the @c this pointer of the possessing object is stored)
-            inline SmartPtr(T* pointer, bool bAddRef = true) : pointer_(pointer), base_(pointer)
-            {
-                if (this->base_ && bAddRef)
-                    this->base_->incrementReferenceCount();
-            }
-
-            /// Copy-constructor
-            inline SmartPtr(const SmartPtr& other) : pointer_(other.pointer_), base_(other.base_)
-            {
-                if (this->base_)
-                    this->base_->incrementReferenceCount();
-            }
-
-            /// Copy-constructor for smart pointers to objects of another class.
-            template <class O>
-            inline SmartPtr(const SmartPtr<O>& other) : pointer_(other.get()), base_(other.base_)
-            {
-                if (this->base_)
-                    this->base_->incrementReferenceCount();
-            }
-
-            /// Constructor: Initializes the smart pointer with the pointer that is stored in a WeakPtr.
-            template <class O>
-            inline SmartPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
-            {
-                if (this->base_)
-                    this->base_->incrementReferenceCount();
-            }
-
-            /// Destructor: Decrements the reference counter.
-            inline ~SmartPtr()
-            {
-                if (this->base_)
-                    this->base_->decrementReferenceCount();
-            }
-
-            /// Assigns a new pointer.
-            inline SmartPtr& operator=(T* pointer)
-            {
-                SmartPtr(pointer).swap(*this);
-                return *this;
-            }
-
-            /// Assigns the wrapped pointer of another SmartPtr.
-            inline SmartPtr& operator=(const SmartPtr& other)
-            {
-                SmartPtr(other).swap(*this);
-                return *this;
-            }
-
-            /// Assigns the wrapped pointer of a SmartPtr of another class
-            template <class O>
-            inline SmartPtr& operator=(const SmartPtr<O>& other)
-            {
-                SmartPtr(other).swap(*this);
-                return *this;
-            }
-
-            /// Assigns the wrapped pointer of a WeakPtr.
-            template <class O>
-            inline SmartPtr& operator=(const WeakPtr<O>& other)
-            {
-                SmartPtr(other).swap(*this);
-                return *this;
-            }
-
-            /// Returns the wrapped pointer as @c T*
-            inline T* get() const
-            {
-                return this->pointer_;
-            }
-
-            /// Returns the wrapped pointer as @c Destroyable*
-            inline Destroyable* getBase() const
-            {
-                return this->base_;
-            }
-
-            /// Implicitly converts the SmartPtr to a pointer of type @c T*
-            inline operator T*() const
-            {
-                return this->pointer_;
-            }
-
-            /// Overloaded operator, returns a pointer to the stored object.
-            inline T* operator->() const
-            {
-                assert(this->pointer_ != 0);
-                return this->pointer_;
-            }
-
-            /// Overloaded operator, returns a reference to the stored object.
-            inline T& operator*() const
-            {
-                assert(this->pointer_ != 0);
-                return *this->pointer_;
-            }
-
-            /// Returns true if the wrapped pointer is NULL.
-            inline bool operator!() const
-            {
-                return (this->pointer_ == 0);
-            }
-
-            /// Swaps the contents of two smart pointers.
-            inline void swap(SmartPtr& other)
-            {
-                {
-                    T* temp = this->pointer_;
-                    this->pointer_ = other.pointer_;
-                    other.pointer_ = temp;
-                }
-                {
-                    Destroyable* temp = this->base_;
-                    this->base_ = other.base_;
-                    other.base_ = temp;
-                }
-            }
-
-            /// Resets the smart pointer (equivalent to assigning a NULL pointer).
-            inline void reset()
-            {
-                SmartPtr().swap(*this);
-            }
-
-        private:
-            T* pointer_;            ///< The wrapped pointer to an object of type @a T
-            Destroyable* base_;    ///< The wrapped pointer, casted up to Destroyable (this is needed because with just a T* pointer, SmartPtr couln't be used with forward declarations)
-    };
-
-    /// Swaps the contents of two smart pointers.
-    template <class T>
-    void swap(SmartPtr<T>& a, SmartPtr<T>& b)
-    {
-        a.swap(b);
-    }
-
-    /// Uses a static_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
-    template <class T, class U>
-    SmartPtr<T> static_pointer_cast(const SmartPtr<U>& p)
-    {
-        return static_cast<T*>(p.get());
-    }
-
-    /// Uses a const_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
-    template <class T, class U>
-    SmartPtr<T> const_pointer_cast(const SmartPtr<U>& p)
-    {
-        return const_cast<T*>(p.get());
-    }
-
-    /// Uses a dynamic_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
-    template <class T, class U>
-    SmartPtr<T> dynamic_pointer_cast(const SmartPtr<U>& p)
-    {
-        return orxonox_cast<T*>(p.get());
-    }
-}
-
-#endif /* _SmartPtr_H__ */
Index: code/branches/core7/src/libraries/core/object/StrongPtr.h
===================================================================
--- code/branches/core7/src/libraries/core/object/StrongPtr.h	(revision 10555)
+++ code/branches/core7/src/libraries/core/object/StrongPtr.h	(revision 10555)
@@ -0,0 +1,304 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+// Inspired by boost::intrusive_ptr by Peter Dimov
+
+/**
+    @defgroup SmartPtr StrongPtr<T> and WeakPtr<T>
+    @ingroup Object
+*/
+
+/**
+    @file
+    @ingroup Object SmartPtr
+    @brief Definition of StrongPtr<T>, wraps a pointer to an object and keeps it alive.
+
+    @anchor StrongPtrExample
+
+    orxonox::StrongPtr is an implementation of a smart pointer - it wraps a pointer to an
+    object  and keeps this object alive until no StrongPtr points to this object anymore.
+    In contrast to orxonox::SharedPtr, StrongPtr works only with classes that are derived
+    from orxonox::Destroyable, because it's an intrusive implementation, meaning the
+    reference counter is stored in the object itself.
+
+    It's possible to use normal pointers and strong pointers to an object simultaneously.
+    You don't have to use StrongPtr all the time, you can create a StrongPtr for an object
+    at any time and also convert it back to a normal pointer if you like. This is possible
+    because the reference counter is stored in the object itself and not in StrongPtr (in
+    contrast to SharedPtr).
+
+    @b Important: If you want to delete an object, you must not use @c delete @c object but
+    rather @c object->destroy(). This function will check if there are strong pointers
+    pointing to the object. If yes, the object will be kept alive until all strong pointers
+    are destroyed. If no, the object is deleted instantly.
+
+    If all strong pointers that point to an object are destroyed, but you never called
+    @c object->destroy() before, the object will not be deleted! All a StrongPtr will do
+    is to really just keep an object alive, but it will not delete it automatically
+    unless you tried to destroy it before.
+
+    Example:
+    @code
+    class MyClass                                           // class declaration
+    {
+        public:
+            void setObject(OtherClass* object)              // passes a normal pointer which will be stored in a StrongPtr
+                { this->object_ = object; }
+
+            OtherClass* getObject() const                   // converts the StrongPtr to a normal pointer and returns it
+                { return this->object_; }
+
+        private:
+            StrongPtr<OtherClass> object_;                  // a pointer to an instance of OtherClass is stored in a StrongPtr
+    };
+    @endcode
+    In this example we assume that OtherClass is a child of Destroyable. We don't care
+    about the inheritance of MyClass though.
+
+    Now we create an instance of MyClass and assign a pointer to an instance of OtherClass:
+    @code
+    MyClass* myclass = new MyClass();                       // create an instance of MyClass
+    OtherClass* object = new OtherClass();                  // create an instance of OtherClass
+    myclass->setObject(object);                             // the object is now stored in a StrongPtr inside myclass
+
+    object->destroy();                                      // we try to destroy object, but there's still a StrongPtr pointing at it.
+
+    # object still exists at this point (because a StrongPtr points at it)
+
+    delete myclass;                                         // now we delete myclass, which also destroys the StrongPtr
+
+    # object doesn't exist anymore (because the StrongPtr is now destroyed)
+    @endcode
+
+    Now we look at the same example, but we first delete myclass, then destroy object:
+    @code
+    MyClass* myclass = new MyClass();                       // create an instance of MyClass
+    OtherClass* object = new OtherClass();                  // create an instance of OtherClass
+    myclass->setObject(object);                             // the object is now stored in a StrongPtr inside myclass
+
+    delete myclass;                                         // we delete myclass, which also destroys the StrongPtr
+
+    # object still exists at this point (because destroy() was not called yet)
+
+    object->destroy();                                      // now we try to destroy object, which works instantly
+
+    # object doesn't exist anymore (because we just destroyed it)
+    @endcode
+
+    Note that in any case @c object->destroy() has to be called to delete the object.
+    However if a StrongPtr points at it, the destruction is delayed until all StrongPtr
+    are destroyed.
+*/
+
+#ifndef _StrongPtr_H__
+#define _StrongPtr_H__
+
+#include "core/CorePrereqs.h"
+
+#include <cassert>
+
+#include "core/object/Destroyable.h"
+#include "WeakPtr.h"
+
+namespace orxonox
+{
+    /**
+        @brief A strong pointer which wraps a pointer to an object and keeps this object alive as long as the strong pointer exists.
+
+        @see See @ref StrongPtrExample "this description" for more information and an example.
+    */
+    template <class T>
+    class StrongPtr
+    {
+        public:
+            /// Constructor: Initializes the strong pointer with a null pointer.
+            inline StrongPtr() : pointer_(0), base_(0)
+            {
+            }
+
+            /// Constructor: Initializes the strong pointer with a pointer to an object. @param pointer The pointer @param bAddRef If true, the reference counter is increased. Don't set this to false unless you know exactly what you're doing! (for example to avoid circular references if the @c this pointer of the possessing object is stored)
+            inline StrongPtr(T* pointer, bool bAddRef = true) : pointer_(pointer), base_(pointer)
+            {
+                if (this->base_ && bAddRef)
+                    this->base_->incrementReferenceCount();
+            }
+
+            /// Copy-constructor
+            inline StrongPtr(const StrongPtr& other) : pointer_(other.pointer_), base_(other.base_)
+            {
+                if (this->base_)
+                    this->base_->incrementReferenceCount();
+            }
+
+            /// Copy-constructor for strong pointers to objects of another class.
+            template <class O>
+            inline StrongPtr(const StrongPtr<O>& other) : pointer_(other.get()), base_(other.base_)
+            {
+                if (this->base_)
+                    this->base_->incrementReferenceCount();
+            }
+
+            /// Constructor: Initializes the strong pointer with the pointer that is stored in a WeakPtr.
+            template <class O>
+            inline StrongPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
+            {
+                if (this->base_)
+                    this->base_->incrementReferenceCount();
+            }
+
+            /// Destructor: Decrements the reference counter.
+            inline ~StrongPtr()
+            {
+                if (this->base_)
+                    this->base_->decrementReferenceCount();
+            }
+
+            /// Assigns a new pointer.
+            inline StrongPtr& operator=(T* pointer)
+            {
+                StrongPtr(pointer).swap(*this);
+                return *this;
+            }
+
+            /// Assigns the wrapped pointer of another StrongPtr.
+            inline StrongPtr& operator=(const StrongPtr& other)
+            {
+                StrongPtr(other).swap(*this);
+                return *this;
+            }
+
+            /// Assigns the wrapped pointer of a StrongPtr of another class
+            template <class O>
+            inline StrongPtr& operator=(const StrongPtr<O>& other)
+            {
+                StrongPtr(other).swap(*this);
+                return *this;
+            }
+
+            /// Assigns the wrapped pointer of a WeakPtr.
+            template <class O>
+            inline StrongPtr& operator=(const WeakPtr<O>& other)
+            {
+                StrongPtr(other).swap(*this);
+                return *this;
+            }
+
+            /// Returns the wrapped pointer as @c T*
+            inline T* get() const
+            {
+                return this->pointer_;
+            }
+
+            /// Returns the wrapped pointer as @c Destroyable*
+            inline Destroyable* getBase() const
+            {
+                return this->base_;
+            }
+
+            /// Implicitly converts the StrongPtr to a pointer of type @c T*
+            inline operator T*() const
+            {
+                return this->pointer_;
+            }
+
+            /// Overloaded operator, returns a pointer to the stored object.
+            inline T* operator->() const
+            {
+                assert(this->pointer_ != 0);
+                return this->pointer_;
+            }
+
+            /// Overloaded operator, returns a reference to the stored object.
+            inline T& operator*() const
+            {
+                assert(this->pointer_ != 0);
+                return *this->pointer_;
+            }
+
+            /// Returns true if the wrapped pointer is NULL.
+            inline bool operator!() const
+            {
+                return (this->pointer_ == 0);
+            }
+
+            /// Swaps the contents of two strong pointers.
+            inline void swap(StrongPtr& other)
+            {
+                {
+                    T* temp = this->pointer_;
+                    this->pointer_ = other.pointer_;
+                    other.pointer_ = temp;
+                }
+                {
+                    Destroyable* temp = this->base_;
+                    this->base_ = other.base_;
+                    other.base_ = temp;
+                }
+            }
+
+            /// Resets the strong pointer (equivalent to assigning a NULL pointer).
+            inline void reset()
+            {
+                StrongPtr().swap(*this);
+            }
+
+        private:
+            T* pointer_;            ///< The wrapped pointer to an object of type @a T
+            Destroyable* base_;    ///< The wrapped pointer, casted up to Destroyable (this is needed because with just a T* pointer, StrongPtr couln't be used with forward declarations)
+    };
+
+    /// Swaps the contents of two strong pointers.
+    template <class T>
+    void swap(StrongPtr<T>& a, StrongPtr<T>& b)
+    {
+        a.swap(b);
+    }
+
+    /// Uses a static_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new StrongPtr<T>.
+    template <class T, class U>
+    StrongPtr<T> static_pointer_cast(const StrongPtr<U>& p)
+    {
+        return static_cast<T*>(p.get());
+    }
+
+    /// Uses a const_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new StrongPtr<T>.
+    template <class T, class U>
+    StrongPtr<T> const_pointer_cast(const StrongPtr<U>& p)
+    {
+        return const_cast<T*>(p.get());
+    }
+
+    /// Uses a dynamic_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new StrongPtr<T>.
+    template <class T, class U>
+    StrongPtr<T> dynamic_pointer_cast(const StrongPtr<U>& p)
+    {
+        return orxonox_cast<T*>(p.get());
+    }
+}
+
+#endif /* _StrongPtr_H__ */
