Index: code/branches/core7/src/libraries/core/BaseObject.h
===================================================================
--- code/branches/core7/src/libraries/core/BaseObject.h	(revision 10554)
+++ code/branches/core7/src/libraries/core/BaseObject.h	(revision 10555)
@@ -51,5 +51,5 @@
 #include "class/OrxonoxClass.h"
 #include "class/Super.h"
-#include "object/SmartPtr.h"
+#include "object/StrongPtr.h"
 
 namespace orxonox
@@ -138,15 +138,15 @@
                 { return this->templates_; }
 
-            inline void setNamespace(const SmartPtr<Namespace>& ns) { this->namespace_ = ns; }
-            inline const SmartPtr<Namespace>& getNamespace() const { return this->namespace_; }
+            inline void setNamespace(const StrongPtr<Namespace>& ns) { this->namespace_ = ns; }
+            inline const StrongPtr<Namespace>& getNamespace() const { return this->namespace_; }
 
             inline void setCreator(BaseObject* creator) { this->creator_ = creator; }
             inline BaseObject* getCreator() const { return this->creator_; }
 
-            inline void setScene(const SmartPtr<Scene>& scene, uint32_t sceneID) { this->scene_ = scene; this->sceneID_=sceneID; }
-            inline const SmartPtr<Scene>& getScene() const { return this->scene_; }
+            inline void setScene(const StrongPtr<Scene>& scene, uint32_t sceneID) { this->scene_ = scene; this->sceneID_=sceneID; }
+            inline const StrongPtr<Scene>& getScene() const { return this->scene_; }
             inline virtual uint32_t getSceneID() const { return this->sceneID_; }
 
-            inline void setGametype(const SmartPtr<Gametype>& gametype)
+            inline void setGametype(const StrongPtr<Gametype>& gametype)
             {
                 if (gametype != this->gametype_)
@@ -157,9 +157,9 @@
                 }
             }
-            inline const SmartPtr<Gametype>& getGametype() const { return this->gametype_; }
+            inline const StrongPtr<Gametype>& getGametype() const { return this->gametype_; }
             inline Gametype* getOldGametype() const { return this->oldGametype_; }
             virtual void changedGametype() {}
 
-            inline void setLevel(const SmartPtr<Level>& level)
+            inline void setLevel(const StrongPtr<Level>& level)
             {
                 if (level != this->level_)
@@ -169,5 +169,5 @@
                 }
             }
-            inline const SmartPtr<Level>& getLevel() const { return this->level_; }
+            inline const StrongPtr<Level>& getLevel() const { return this->level_; }
             virtual void changedLevel() {}
 
@@ -222,11 +222,11 @@
             std::map<std::string, std::string> xmlAttributes_; //!< Lowercase XML attributes
             std::string            loaderIndentation_;         //!< Indentation of the debug output in the Loader
-            SmartPtr<Namespace>    namespace_;
+            StrongPtr<Namespace>   namespace_;
             BaseObject*            creator_;
-            SmartPtr<Scene>        scene_;
+            StrongPtr<Scene>       scene_;
             uint32_t               sceneID_;
-            SmartPtr<Gametype>     gametype_;
+            StrongPtr<Gametype>    gametype_;
             Gametype*              oldGametype_;
-            SmartPtr<Level>        level_;
+            StrongPtr<Level>       level_;
             std::set<Template*>    templates_;
 
Index: code/branches/core7/src/libraries/core/CorePrereqs.h
===================================================================
--- code/branches/core7/src/libraries/core/CorePrereqs.h	(revision 10554)
+++ code/branches/core7/src/libraries/core/CorePrereqs.h	(revision 10555)
@@ -218,9 +218,9 @@
     class ScopedSingletonWrapper;
     class SettingsConfigFile;
-    template <class T>
-    class SmartPtr;
     class StaticallyInitializedInstance;
     class StaticInitializationHandler;
     class StaticInitializationManager;
+    template <class T>
+    class StrongPtr;
     template <class T>
     class SubclassIdentifier;
Index: code/branches/core7/src/libraries/core/CoreStaticInitializationHandler.cc
===================================================================
--- code/branches/core7/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 10554)
+++ code/branches/core7/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 10555)
@@ -102,12 +102,12 @@
             identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(*it)->getIdentifier());
 
-        // destroy objects. some objects may survive this at first because they still have smart pointers pointing at them. this is
-        // ok as long as those smart pointers are held by objects that are also about to be destroyed in the same loop. this means
-        // that objects within one module may reference each other by smart pointers. but it is not allowed that objects from another
-        // module (which is not unloaded) uses smart pointers to point at objects inside the unloaded module. this will lead to a crash.
+        // destroy objects. some objects may survive this at first because they still have strong pointers pointing at them. this is
+        // ok as long as those strong pointers are held by objects that are also about to be destroyed in the same loop. this means
+        // that objects within one module may reference each other by strong pointers. but it is not allowed that objects from another
+        // module (which is not unloaded) uses strong pointers to point at objects inside the unloaded module. this will lead to a crash.
         for (std::set<Identifier*>::iterator it = identifiers.begin(); it != identifiers.end(); ++it)
             (*it)->destroyObjects();
 
-        // check if all objects were really destroyed. this is not the case if an object is referenced by a smart pointer from another
+        // check if all objects were really destroyed. this is not the case if an object is referenced by a strong pointer from another
         // module (or if two objects inside this module reference each other). this will lead to a crash and must be fixed (e.g. by
         // changing object dependencies; or by changing the logic that allows modules to be unloaded).
Index: code/branches/core7/src/libraries/core/Namespace.cc
===================================================================
--- code/branches/core7/src/libraries/core/Namespace.cc	(revision 10554)
+++ code/branches/core7/src/libraries/core/Namespace.cc	(revision 10555)
@@ -47,5 +47,5 @@
         RegisterObject(Namespace);
 
-        this->setNamespace(SmartPtr<Namespace>(this, false));
+        this->setNamespace(StrongPtr<Namespace>(this, false));
     }
 
Index: code/branches/core7/src/libraries/core/object/DestroyLaterManager.cc
===================================================================
--- code/branches/core7/src/libraries/core/object/DestroyLaterManager.cc	(revision 10554)
+++ 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 10554)
+++ 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 10554)
+++ 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 10554)
+++ 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 10554)
+++ 	(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__ */
Index: code/branches/core7/src/libraries/network/synchronisable/Serialise.h
===================================================================
--- code/branches/core7/src/libraries/network/synchronisable/Serialise.h	(revision 10554)
+++ code/branches/core7/src/libraries/network/synchronisable/Serialise.h	(revision 10555)
@@ -78,8 +78,8 @@
     }
 
-    // These functions implement loading / saving / etc. for SmartPtr<T>
+    // These functions implement loading / saving / etc. for StrongPtr<T>
 
     /** @brief returns the size of the objectID needed to synchronise the pointer */
-    template <class T> inline uint32_t returnSize( const SmartPtr<T>& )
+    template <class T> inline uint32_t returnSize( const StrongPtr<T>& )
     {
         return sizeof(uint32_t);
@@ -87,13 +87,13 @@
 
     /** @brief reads the objectID of a pointer out of the bytestream and increases the mem pointer */
-    template <class T> inline void loadAndIncrease( const SmartPtr<T>& variable, uint8_t*& mem )
+    template <class T> inline void loadAndIncrease( const StrongPtr<T>& variable, uint8_t*& mem )
     {
 //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<SmartPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
 
     /** @brief saves the objectID of a pointer into the bytestream and increases the mem pointer */
-    template <class T> inline void saveAndIncrease( const SmartPtr<T>& variable, uint8_t*& mem )
+    template <class T> inline void saveAndIncrease( const StrongPtr<T>& variable, uint8_t*& mem )
     {
         if ( variable.get() )
@@ -105,5 +105,5 @@
 
     /** @brief checks whether the objectID of the variable is the same as in the bytestream */
-    template <class T> inline  bool checkEquality( const SmartPtr<T>& variable, uint8_t* mem )
+    template <class T> inline  bool checkEquality( const StrongPtr<T>& variable, uint8_t* mem )
     {
         if ( variable.get() )
@@ -125,5 +125,5 @@
     {
         //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<SmartPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
Index: code/branches/core7/src/modules/overlays/hud/HUDHealthBar.h
===================================================================
--- code/branches/core7/src/modules/overlays/hud/HUDHealthBar.h	(revision 10554)
+++ code/branches/core7/src/modules/overlays/hud/HUDHealthBar.h	(revision 10555)
@@ -115,5 +115,5 @@
         private:
             WeakPtr<Pawn> owner_;
-            SmartPtr<OverlayText> textoverlay_;
+            StrongPtr<OverlayText> textoverlay_;
             bool bUseBarColour_;
             ColourValue textColour_;
Index: code/branches/core7/src/modules/pickup/PickupSpawner.cc
===================================================================
--- code/branches/core7/src/modules/pickup/PickupSpawner.cc	(revision 10554)
+++ code/branches/core7/src/modules/pickup/PickupSpawner.cc	(revision 10555)
@@ -145,5 +145,6 @@
         if(GameMode::isMaster() && this->isActive())
         {
-            WeakPtr<PickupSpawner> spawner = this; // Create a smart pointer to keep the PickupSpawner alive until we iterated through all Pawns (in case a Pawn takes the last pickup)
+            // TODO: why is this a WeakPtr when the comment says StrongPtr?
+            WeakPtr<PickupSpawner> spawner = this; // Create a strong pointer to keep the PickupSpawner alive until we iterated through all Pawns (in case a Pawn takes the last pickup)
 
             // Remove PickupCarriers from the blocked list if they have exceeded their time.
Index: code/branches/core7/src/modules/pickup/items/ShrinkPickup.cc
===================================================================
--- code/branches/core7/src/modules/pickup/items/ShrinkPickup.cc	(revision 10554)
+++ code/branches/core7/src/modules/pickup/items/ShrinkPickup.cc	(revision 10555)
@@ -182,5 +182,5 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< SmartPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
@@ -208,5 +208,5 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< SmartPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
@@ -263,5 +263,5 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< SmartPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
@@ -304,5 +304,5 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< SmartPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
Index: code/branches/core7/src/modules/tetris/Tetris.cc
===================================================================
--- code/branches/core7/src/modules/tetris/Tetris.cc	(revision 10554)
+++ code/branches/core7/src/modules/tetris/Tetris.cc	(revision 10555)
@@ -104,5 +104,5 @@
         }
 
-        for (std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for (std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
             (*it)->destroy();
         this->stones_.clear();
@@ -136,5 +136,5 @@
             return false;
 
-        for(std::list<SmartPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for(std::list<StrongPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
         {
             const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
@@ -192,5 +192,5 @@
 
         // check for collisions with all stones
-        for(std::list<SmartPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for(std::list<StrongPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
         {
             //Vector3 currentStonePosition = rotateVector((*it)->getPosition(), this->activeBrick_->getRotationCount());
@@ -469,7 +469,7 @@
         {
             stonesPerRow = 0;
-            for(std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
-            {
-                std::list<SmartPtr<TetrisStone> >::iterator it_temp = it++;
+            for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
+            {
+                std::list<StrongPtr<TetrisStone> >::iterator it_temp = it++;
                 correctPosition = static_cast<unsigned int>(((*it_temp)->getPosition().y - 5)/this->center_->getStoneSize());
                 if(correctPosition == row)
@@ -491,5 +491,5 @@
     void Tetris::clearRow(unsigned int row)
     {// clear the full row
-        for(std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
+        for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
         {
             if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) == row)
@@ -502,5 +502,5 @@
         }
       // adjust height of stones above the deleted row //TODO: check if this could be a source of a bug.
-        for(std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
         {
             if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) > row)
Index: code/branches/core7/src/modules/tetris/Tetris.h
===================================================================
--- code/branches/core7/src/modules/tetris/Tetris.h	(revision 10554)
+++ code/branches/core7/src/modules/tetris/Tetris.h	(revision 10555)
@@ -94,5 +94,5 @@
 
             WeakPtr<TetrisCenterpoint> center_; //!< The playing field.
-            std::list<SmartPtr<TetrisStone> > stones_; //!< A list of all stones in play.
+            std::list<StrongPtr<TetrisStone> > stones_; //!< A list of all stones in play.
             WeakPtr<TetrisBrick> activeBrick_;
             WeakPtr<TetrisBrick> futureBrick_;
Index: code/branches/core7/src/orxonox/Scene.cc
===================================================================
--- code/branches/core7/src/orxonox/Scene.cc	(revision 10554)
+++ code/branches/core7/src/orxonox/Scene.cc	(revision 10555)
@@ -62,5 +62,5 @@
         RegisterObject(Scene);
 
-        this->setScene(SmartPtr<Scene>(this, false), OBJECTID_UNKNOWN);
+        this->setScene(StrongPtr<Scene>(this, false), OBJECTID_UNKNOWN);
         this->bShadows_ = true;
         this->bDebugDrawPhysics_ = false;
@@ -366,6 +366,6 @@
     {
         // get the WorldEntity pointers
-        SmartPtr<WorldEntity> object0 = static_cast<WorldEntity*>(colObj0->getUserPointer());
-        SmartPtr<WorldEntity> object1 = static_cast<WorldEntity*>(colObj1->getUserPointer());
+        StrongPtr<WorldEntity> object0 = static_cast<WorldEntity*>(colObj0->getUserPointer());
+        StrongPtr<WorldEntity> object1 = static_cast<WorldEntity*>(colObj1->getUserPointer());
 
         // get the CollisionShape pointers
Index: code/branches/core7/src/orxonox/gametypes/Gametype.cc
===================================================================
--- code/branches/core7/src/orxonox/gametypes/Gametype.cc	(revision 10554)
+++ code/branches/core7/src/orxonox/gametypes/Gametype.cc	(revision 10555)
@@ -61,5 +61,5 @@
         RegisterObject(Gametype);
 
-        this->setGametype(SmartPtr<Gametype>(this, false));
+        this->setGametype(StrongPtr<Gametype>(this, false));
 
         this->gtinfo_ = new GametypeInfo(context);
Index: code/branches/core7/src/orxonox/interfaces/RadarViewable.h
===================================================================
--- code/branches/core7/src/orxonox/interfaces/RadarViewable.h	(revision 10554)
+++ code/branches/core7/src/orxonox/interfaces/RadarViewable.h	(revision 10555)
@@ -37,5 +37,5 @@
 #include "util/Math.h"
 #include "core/class/OrxonoxInterface.h"
-#include "core/object/SmartPtr.h"
+#include "core/object/StrongPtr.h"
 
 namespace orxonox
@@ -163,5 +163,5 @@
         //Radar
         const WorldEntity* wePtr_;
-        SmartPtr<Radar> radar_;
+        StrongPtr<Radar> radar_;
         float radarObjectCamouflage_;
         Shape radarObjectShape_;
Index: code/branches/core7/src/orxonox/overlays/OverlayGroup.cc
===================================================================
--- code/branches/core7/src/orxonox/overlays/OverlayGroup.cc	(revision 10554)
+++ code/branches/core7/src/orxonox/overlays/OverlayGroup.cc	(revision 10555)
@@ -61,5 +61,5 @@
     OverlayGroup::~OverlayGroup()
     {
-        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->destroy();
         this->hudElements_.clear();
@@ -85,5 +85,5 @@
     void OverlayGroup::setScale(const Vector2& scale)
     {
-        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->scale(scale / this->scale_);
         this->scale_ = scale;
@@ -93,5 +93,5 @@
     void OverlayGroup::setScroll(const Vector2& scroll)
     {
-        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->scroll(scroll - this->scroll_);
         this->scroll_ = scroll;
@@ -106,5 +106,5 @@
     void OverlayGroup::addElement(OrxonoxOverlay* element)
     {
-        hudElements_.insert(SmartPtr<OrxonoxOverlay>(element));
+        hudElements_.insert(StrongPtr<OrxonoxOverlay>(element));
         element->setOverlayGroup( this );
         if (this->owner_)
@@ -122,5 +122,5 @@
     bool OverlayGroup::removeElement(OrxonoxOverlay* element)
     {
-        if(this->hudElements_.erase(SmartPtr<OrxonoxOverlay>(element)) == 0)
+        if(this->hudElements_.erase(StrongPtr<OrxonoxOverlay>(element)) == 0)
             return false;
         return true;
@@ -132,5 +132,5 @@
         if (index < this->hudElements_.size())
         {
-            std::set< SmartPtr<OrxonoxOverlay> >::const_iterator it = hudElements_.begin();
+            std::set< StrongPtr<OrxonoxOverlay> >::const_iterator it = hudElements_.begin();
             for (unsigned int i = 0; i != index; ++it, ++i)
                 ;
@@ -146,5 +146,5 @@
         SUPER( OverlayGroup, changedVisibility );
 
-        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->changedVisibility(); //inform all Child Overlays that our visibility has changed
     }
@@ -155,5 +155,5 @@
         SUPER( OverlayGroup, changedGametype );
 
-        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->setGametype(this->getGametype());
     }
@@ -163,5 +163,5 @@
         this->owner_ = owner;
 
-        for (std::set< SmartPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->setOwner(owner);
     }
Index: code/branches/core7/src/orxonox/overlays/OverlayGroup.h
===================================================================
--- code/branches/core7/src/orxonox/overlays/OverlayGroup.h	(revision 10554)
+++ code/branches/core7/src/orxonox/overlays/OverlayGroup.h	(revision 10555)
@@ -65,5 +65,5 @@
         static void scrollGroup(const std::string& name, const Vector2& scroll);
 
-        inline const std::set< SmartPtr<OrxonoxOverlay> >& getOverlays() const
+        inline const std::set< StrongPtr<OrxonoxOverlay> >& getOverlays() const
             { return this->hudElements_; }
 
@@ -92,5 +92,5 @@
 
     private:
-        std::set< SmartPtr<OrxonoxOverlay> > hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
+        std::set< StrongPtr<OrxonoxOverlay> > hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
         Vector2 scale_;                            //!< Current scale (independent of the elements).
         Vector2 scroll_;                           //!< Current scrolling offset.
Index: code/branches/core7/src/orxonox/sound/AmbientSound.cc
===================================================================
--- code/branches/core7/src/orxonox/sound/AmbientSound.cc	(revision 10554)
+++ code/branches/core7/src/orxonox/sound/AmbientSound.cc	(revision 10555)
@@ -51,5 +51,5 @@
         if (GameMode::playsSound())
         {
-            // Smoothly fade out by keeping a SmartPtr
+            // Smoothly fade out by keeping a StrongPtr
             SoundManager::getInstance().unregisterAmbientSound(this);
         }
Index: code/branches/core7/src/orxonox/sound/SoundBuffer.h
===================================================================
--- code/branches/core7/src/orxonox/sound/SoundBuffer.h	(revision 10554)
+++ code/branches/core7/src/orxonox/sound/SoundBuffer.h	(revision 10555)
@@ -46,5 +46,5 @@
         friend class SoundManager;
 #if !defined(_MSC_VER) || _MSC_VER >= 1500
-        // Make sure nobody deletes an instance (using smart pointers)
+        // Make sure nobody deletes an instance (using strong pointers)
         template <class T>
         friend void boost::checked_delete(T*);
Index: code/branches/core7/src/orxonox/sound/SoundManager.cc
===================================================================
--- code/branches/core7/src/orxonox/sound/SoundManager.cc	(revision 10554)
+++ code/branches/core7/src/orxonox/sound/SoundManager.cc	(revision 10555)
@@ -165,5 +165,5 @@
     SoundManager::~SoundManager()
     {
-        // Erase fade lists because of the smart pointers
+        // Erase fade lists because of the strong pointers
         this->bDestructorCalled_ = true;
         this->fadeInList_.clear();
@@ -419,8 +419,8 @@
     }
 
-    void SoundManager::fadeIn(const SmartPtr<AmbientSound>& sound)
+    void SoundManager::fadeIn(const StrongPtr<AmbientSound>& sound)
     {
         // If we're already fading out --> remove that
-        for (std::list<SmartPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
+        for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
         {
             if (*it == sound)
@@ -435,8 +435,8 @@
     }
 
-    void SoundManager::fadeOut(const SmartPtr<AmbientSound>& sound)
+    void SoundManager::fadeOut(const StrongPtr<AmbientSound>& sound)
     {
         // If we're already fading in --> remove that
-        for (std::list<SmartPtr<AmbientSound> >::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
+        for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
         {
             if (*it == sound)
@@ -461,5 +461,5 @@
 
         // FADE IN
-        for (std::list<SmartPtr<AmbientSound> >::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
+        for (std::list<StrongPtr<AmbientSound> >::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
         {
             if ((*it)->getVolume() + this->crossFadeStep_*dt > 1.0f)
@@ -476,5 +476,5 @@
 
         // FADE OUT
-        for (std::list<SmartPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
+        for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
         {
             if ((*it)->getVolume() - this->crossFadeStep_*dt < 0.0f)
Index: code/branches/core7/src/orxonox/sound/SoundManager.h
===================================================================
--- code/branches/core7/src/orxonox/sound/SoundManager.h	(revision 10554)
+++ code/branches/core7/src/orxonox/sound/SoundManager.h	(revision 10555)
@@ -40,5 +40,5 @@
 #include "util/Singleton.h"
 #include "core/config/Configurable.h"
-#include "core/object/SmartPtr.h"
+#include "core/object/StrongPtr.h"
 #include "core/UpdateListener.h"
 
@@ -106,6 +106,6 @@
     private:
         void processCrossFading(float dt);
-        void fadeIn(const SmartPtr<AmbientSound>& sound);
-        void fadeOut(const SmartPtr<AmbientSound>& sound);
+        void fadeIn(const StrongPtr<AmbientSound>& sound);
+        void fadeOut(const StrongPtr<AmbientSound>& sound);
 
         void checkFadeStepValidity();
@@ -129,6 +129,6 @@
         //! Absolute change per second (0.1 means 10% of the nominal volume) for cross fading
         float                              crossFadeStep_;
-        std::list<SmartPtr<AmbientSound> > fadeInList_;
-        std::list<SmartPtr<AmbientSound> > fadeOutList_;
+        std::list<StrongPtr<AmbientSound> > fadeInList_;
+        std::list<StrongPtr<AmbientSound> > fadeOutList_;
 
         // Volume related
Index: code/branches/core7/src/orxonox/worldentities/ControllableEntity.cc
===================================================================
--- code/branches/core7/src/orxonox/worldentities/ControllableEntity.cc	(revision 10554)
+++ code/branches/core7/src/orxonox/worldentities/ControllableEntity.cc	(revision 10555)
@@ -108,5 +108,5 @@
                 this->camera_->destroy();
 
-            for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+            for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 (*it)->destroy();
 
@@ -165,5 +165,5 @@
     {
         unsigned int i = 0;
-        for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+        for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
         {
             if (i == index)
@@ -180,5 +180,5 @@
 
         unsigned int counter = 0;
-        for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+        for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
         {
             if ((*it) == this->currentCameraPosition_)
@@ -219,5 +219,5 @@
             else if (this->cameraPositions_.size() > 0)
             {
-                for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+                for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 {
                     if ((*it) == this->camera_->getParent())
@@ -477,5 +477,5 @@
         if (parent)
         {
-            for (std::list<SmartPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+            for (std::list<StrongPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 if ((*it)->getIsAbsolute())
                     parent->attach((*it));
Index: code/branches/core7/src/orxonox/worldentities/ControllableEntity.h
===================================================================
--- code/branches/core7/src/orxonox/worldentities/ControllableEntity.h	(revision 10554)
+++ code/branches/core7/src/orxonox/worldentities/ControllableEntity.h	(revision 10555)
@@ -114,5 +114,5 @@
             void addCameraPosition(CameraPosition* position);
             CameraPosition* getCameraPosition(unsigned int index) const;
-            inline const std::list<SmartPtr<CameraPosition> >& getCameraPositions() const
+            inline const std::list<StrongPtr<CameraPosition> >& getCameraPositions() const
                 { return this->cameraPositions_; }
             unsigned int getCurrentCameraIndex() const;
@@ -235,5 +235,5 @@
             bool bMouseLook_;
             float mouseLookSpeed_;
-            std::list<SmartPtr<CameraPosition> > cameraPositions_;
+            std::list<StrongPtr<CameraPosition> > cameraPositions_;
             CameraPosition* currentCameraPosition_;
             std::string cameraPositionTemplate_;
Index: code/branches/core7/src/orxonox/worldentities/WorldEntity.cc
===================================================================
--- code/branches/core7/src/orxonox/worldentities/WorldEntity.cc	(revision 10554)
+++ code/branches/core7/src/orxonox/worldentities/WorldEntity.cc	(revision 10555)
@@ -130,5 +130,5 @@
                 WorldEntity* entity = *it;
 
-                // do this for all children, because even if getDeleteWithParent() returns true a child might still stay active due to smart pointers pointing to it
+                // do this for all children, because even if getDeleteWithParent() returns true a child might still stay active due to strong pointers pointing to it
                 entity->setPosition(entity->getWorldPosition());
                 this->detach(entity); // detach also erases the element from the children set
Index: code/branches/core7/test/core/CMakeLists.txt
===================================================================
--- code/branches/core7/test/core/CMakeLists.txt	(revision 10554)
+++ code/branches/core7/test/core/CMakeLists.txt	(revision 10555)
@@ -26,5 +26,5 @@
     object/ObjectListBaseTest.cc
     object/ObjectListIteratorTest.cc
-    object/SmartPtrTest.cc
+    object/StrongPtrTest.cc
     object/WeakPtrTest.cc
     singleton/ScopeTest.cc
Index: code/branches/core7/test/core/object/SmartPtrTest.cc
===================================================================
--- code/branches/core7/test/core/object/SmartPtrTest.cc	(revision 10554)
+++ 	(revision )
@@ -1,143 +1,0 @@
-#include <gtest/gtest.h>
-#include "core/object/SmartPtr.h"
-
-namespace orxonox
-{
-    namespace
-    {
-        class DestroyableTest : public Destroyable
-        {
-            public:
-                DestroyableTest(bool& destroyed) : destroyed_(destroyed) { destroyed_ = false; }
-                virtual ~DestroyableTest() { destroyed_ = true; }
-
-            private:
-                bool& destroyed_;
-        };
-    }
-
-    TEST(SmartPtrTest, CanReferenceObject)
-    {
-        bool bla;
-        DestroyableTest* test = new DestroyableTest(bla);
-        SmartPtr<DestroyableTest> smartPtr = test;
-        EXPECT_EQ(test, smartPtr.get());
-        test->destroy();
-    }
-
-    TEST(SmartPtrTest, IncreasesReferenceCount)
-    {
-        bool bla;
-        DestroyableTest* test = new DestroyableTest(bla);
-        EXPECT_EQ(0u, test->getReferenceCount());
-        {
-            SmartPtr<DestroyableTest> smartPtr = test;
-            EXPECT_EQ(1u, test->getReferenceCount());
-        }
-        EXPECT_EQ(0u, test->getReferenceCount());
-        test->destroy();
-    }
-
-    TEST(SmartPtrTest, DestroyDeletesInstance)
-    {
-        bool destroyed = false;
-        DestroyableTest* test = new DestroyableTest(destroyed);
-        EXPECT_FALSE(destroyed);
-        test->destroy();
-        EXPECT_TRUE(destroyed);
-    }
-
-    TEST(SmartPtrTest, PreventsDestruction)
-    {
-        bool destroyed = false;
-        DestroyableTest* test = new DestroyableTest(destroyed);
-        EXPECT_FALSE(destroyed);
-        SmartPtr<DestroyableTest> smartPtr = test;
-        test->destroy();
-        EXPECT_FALSE(destroyed);
-    }
-
-    TEST(SmartPtrTest, DestroysIfSmartPtrRemoved)
-    {
-        bool destroyed = false;
-        DestroyableTest* test = new DestroyableTest(destroyed);
-        EXPECT_FALSE(destroyed);
-        {
-            SmartPtr<DestroyableTest> smartPtr = test;
-            test->destroy();
-            EXPECT_FALSE(destroyed);
-        }
-        EXPECT_TRUE(destroyed);
-    }
-
-    TEST(SmartPtrTest, DestroysIfAllSmartPtrsRemoved)
-    {
-        bool destroyed = false;
-        DestroyableTest* test = new DestroyableTest(destroyed);
-        EXPECT_FALSE(destroyed);
-        {
-            SmartPtr<DestroyableTest> smartPtr1 = test;
-            {
-                SmartPtr<DestroyableTest> smartPtr2 = test;
-                {
-                    SmartPtr<DestroyableTest> smartPtr3 = test;
-                    test->destroy();
-                    EXPECT_FALSE(destroyed);
-                }
-                EXPECT_FALSE(destroyed);
-            }
-            EXPECT_FALSE(destroyed);
-        }
-        EXPECT_TRUE(destroyed);
-    }
-
-    void isNull(const SmartPtr<DestroyableTest> smartPtr)
-    {
-        EXPECT_TRUE(smartPtr == NULL);
-        EXPECT_TRUE(smartPtr == 0);
-        EXPECT_TRUE(!smartPtr);
-        EXPECT_FALSE(smartPtr != NULL);
-        EXPECT_FALSE(smartPtr != 0);
-        EXPECT_FALSE(smartPtr);
-    }
-
-    TEST(SmartPtrTest, IsNull)
-    {
-        {
-            SmartPtr<DestroyableTest> smartPtr;
-            isNull(smartPtr);
-        }
-        {
-            SmartPtr<DestroyableTest> smartPtr = NULL;
-            isNull(smartPtr);
-        }
-        {
-            SmartPtr<DestroyableTest> smartPtr;
-            smartPtr = NULL;
-            isNull(smartPtr);
-        }
-        {
-            SmartPtr<DestroyableTest> smartPtr = 0;
-            isNull(smartPtr);
-        }
-        {
-            SmartPtr<DestroyableTest> smartPtr;
-            smartPtr = 0;
-            isNull(smartPtr);
-        }
-    }
-
-    TEST(SmartPtrTest, IsNotNull)
-    {
-        bool destroyed = false;
-        DestroyableTest* test = new DestroyableTest(destroyed);
-        SmartPtr<DestroyableTest> smartPtr = test;
-        EXPECT_FALSE(smartPtr == NULL);
-        EXPECT_FALSE(smartPtr == 0);
-        EXPECT_FALSE(!smartPtr);
-        EXPECT_TRUE(smartPtr != NULL);
-        EXPECT_TRUE(smartPtr != 0);
-        EXPECT_TRUE(smartPtr);
-        test->destroy();
-    }
-}
Index: code/branches/core7/test/core/object/StrongPtrTest.cc
===================================================================
--- code/branches/core7/test/core/object/StrongPtrTest.cc	(revision 10555)
+++ code/branches/core7/test/core/object/StrongPtrTest.cc	(revision 10555)
@@ -0,0 +1,143 @@
+#include <gtest/gtest.h>
+#include "core/object/StrongPtr.h"
+
+namespace orxonox
+{
+    namespace
+    {
+        class DestroyableTest : public Destroyable
+        {
+            public:
+                DestroyableTest(bool& destroyed) : destroyed_(destroyed) { destroyed_ = false; }
+                virtual ~DestroyableTest() { destroyed_ = true; }
+
+            private:
+                bool& destroyed_;
+        };
+    }
+
+    TEST(StrongPtrTest, CanReferenceObject)
+    {
+        bool bla;
+        DestroyableTest* test = new DestroyableTest(bla);
+        StrongPtr<DestroyableTest> strongPtr = test;
+        EXPECT_EQ(test, strongPtr.get());
+        test->destroy();
+    }
+
+    TEST(StrongPtrTest, IncreasesReferenceCount)
+    {
+        bool bla;
+        DestroyableTest* test = new DestroyableTest(bla);
+        EXPECT_EQ(0u, test->getReferenceCount());
+        {
+            StrongPtr<DestroyableTest> strongPtr = test;
+            EXPECT_EQ(1u, test->getReferenceCount());
+        }
+        EXPECT_EQ(0u, test->getReferenceCount());
+        test->destroy();
+    }
+
+    TEST(StrongPtrTest, DestroyDeletesInstance)
+    {
+        bool destroyed = false;
+        DestroyableTest* test = new DestroyableTest(destroyed);
+        EXPECT_FALSE(destroyed);
+        test->destroy();
+        EXPECT_TRUE(destroyed);
+    }
+
+    TEST(StrongPtrTest, PreventsDestruction)
+    {
+        bool destroyed = false;
+        DestroyableTest* test = new DestroyableTest(destroyed);
+        EXPECT_FALSE(destroyed);
+        StrongPtr<DestroyableTest> strongPtr = test;
+        test->destroy();
+        EXPECT_FALSE(destroyed);
+    }
+
+    TEST(StrongPtrTest, DestroysIfStrongPtrRemoved)
+    {
+        bool destroyed = false;
+        DestroyableTest* test = new DestroyableTest(destroyed);
+        EXPECT_FALSE(destroyed);
+        {
+            StrongPtr<DestroyableTest> strongPtr = test;
+            test->destroy();
+            EXPECT_FALSE(destroyed);
+        }
+        EXPECT_TRUE(destroyed);
+    }
+
+    TEST(StrongPtrTest, DestroysIfAllStrongPtrsRemoved)
+    {
+        bool destroyed = false;
+        DestroyableTest* test = new DestroyableTest(destroyed);
+        EXPECT_FALSE(destroyed);
+        {
+            StrongPtr<DestroyableTest> strongPtr1 = test;
+            {
+                StrongPtr<DestroyableTest> strongPtr2 = test;
+                {
+                    StrongPtr<DestroyableTest> strongPtr3 = test;
+                    test->destroy();
+                    EXPECT_FALSE(destroyed);
+                }
+                EXPECT_FALSE(destroyed);
+            }
+            EXPECT_FALSE(destroyed);
+        }
+        EXPECT_TRUE(destroyed);
+    }
+
+    void isNull(const StrongPtr<DestroyableTest> strongPtr)
+    {
+        EXPECT_TRUE(strongPtr == NULL);
+        EXPECT_TRUE(strongPtr == 0);
+        EXPECT_TRUE(!strongPtr);
+        EXPECT_FALSE(strongPtr != NULL);
+        EXPECT_FALSE(strongPtr != 0);
+        EXPECT_FALSE(strongPtr);
+    }
+
+    TEST(StrongPtrTest, IsNull)
+    {
+        {
+            StrongPtr<DestroyableTest> strongPtr;
+            isNull(strongPtr);
+        }
+        {
+            StrongPtr<DestroyableTest> strongPtr = NULL;
+            isNull(strongPtr);
+        }
+        {
+            StrongPtr<DestroyableTest> strongPtr;
+            strongPtr = NULL;
+            isNull(strongPtr);
+        }
+        {
+            StrongPtr<DestroyableTest> strongPtr = 0;
+            isNull(strongPtr);
+        }
+        {
+            StrongPtr<DestroyableTest> strongPtr;
+            strongPtr = 0;
+            isNull(strongPtr);
+        }
+    }
+
+    TEST(StrongPtrTest, IsNotNull)
+    {
+        bool destroyed = false;
+        DestroyableTest* test = new DestroyableTest(destroyed);
+        StrongPtr<DestroyableTest> strongPtr = test;
+        EXPECT_FALSE(strongPtr == NULL);
+        EXPECT_FALSE(strongPtr == 0);
+        EXPECT_FALSE(!strongPtr);
+        EXPECT_TRUE(strongPtr != NULL);
+        EXPECT_TRUE(strongPtr != 0);
+        EXPECT_TRUE(strongPtr);
+        test->destroy();
+    }
+}
