Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/core/OrxonoxClass.h @ 8129

Last change on this file since 8129 was 8079, checked in by landauf, 14 years ago

merged usability branch back to trunk

incomplete summary of the changes in this branch:

  • enhanced keyboard navigation in GUIs
  • implemented new graphics menu and changeable window size at runtime
  • added developer mode
  • HUD shows if game is paused, game pauses if ingame menu is opened
  • removed a few obsolete commands and hid some that are more for internal use
  • numpad works in console and gui
  • faster loading of level info
  • enhanced usage of compositors (Shader class)
  • improved camera handling, configurable FOV and aspect ratio
  • Property svn:eol-style set to native
File size: 9.0 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @defgroup OrxonoxClass OrxonoxClass
31    @ingroup Class
32*/
33
34/**
35    @file
36    @ingroup Class OrxonoxClass
37    @brief Declaration of OrxonoxClass, the base class of all objects and interfaces in Orxonox.
38
39    All objects and interfaces of the game-logic (not the engine) are derived from OrxonoxClass.
40    It stores the Identifier and the MetaObjectList and has all needed functions to create and use the class-hierarchy.
41*/
42
43#ifndef _OrxonoxClass_H__
44#define _OrxonoxClass_H__
45
46#include "CorePrereqs.h"
47#include "Super.h"
48
49#include <set>
50#include <vector>
51
52/**
53@def CCOUT
54    Acts almost exactly like COUT(x), but prepends "ClassName: "
55*/
56#define CCOUT(level) \
57    COUT(level) << this->getIdentifier()->getName() << ": "
58
59namespace orxonox
60{
61    /**
62        @brief The class all objects and interfaces of the game-logic (not the engine) are derived from.
63
64        The BaseObject and Interfaces are derived with @c virtual @c public @c OrxonoxClass from OrxonoxClass.
65        OrxonoxClass is needed to create the class-hierarchy at startup and to store the Identifier and the
66        MetaObjectList, as well as to provide an interface for SmartPtr and WeakPtr.
67    */
68    class _CoreExport OrxonoxClass
69    {
70        template <class T>
71        friend class ClassIdentifier;
72
73        template <class T>
74        friend class SmartPtr;
75
76        friend class DestructionListener;
77
78        public:
79            OrxonoxClass();
80            virtual ~OrxonoxClass();
81
82            void destroy();
83            void unregisterObject();
84
85            /// Function to collect the SetConfigValue-macro calls.
86            void setConfigValues() {};
87
88            /// Returns the Identifier of the object.
89            inline Identifier* getIdentifier() const { return this->identifier_; }
90
91            bool isA(const Identifier* identifier);
92            bool isExactlyA(const Identifier* identifier);
93            bool isChildOf(const Identifier* identifier);
94            bool isDirectChildOf(const Identifier* identifier);
95            bool isParentOf(const Identifier* identifier);
96            bool isDirectParentOf(const Identifier* identifier);
97
98            /// Returns true if the object's class is of the given type or a derivative.
99            template <class B> inline bool isA(const SubclassIdentifier<B>* identifier)
100                { return this->isA(*identifier); }
101            /// Returns true if the object's class is exactly of the given type.
102            template <class B> inline bool isExactlyA(const SubclassIdentifier<B>* identifier)
103                { return this->isExactlyA(*identifier); }
104            /// Returns true if the object's class is a child of the given type.
105            template <class B> inline bool isChildOf(const SubclassIdentifier<B>* identifier)
106                { return this->isChildOf(*identifier); }
107            /// Returns true if the object's class is a direct child of the given type.
108            template <class B> inline bool isDirectChildOf(const SubclassIdentifier<B>* identifier)
109                { return this->isDirectChildOf(*identifier); }
110            /// Returns true if the object's class is a parent of the given type.
111            template <class B> inline bool isParentOf(const SubclassIdentifier<B>* identifier)
112                { return this->isParentOf(*identifier); }
113            /// Returns true if the object's class is a direct parent of the given type.
114            template <class B> inline bool isDirectParentOf(const SubclassIdentifier<B>* identifier)
115                { return this->isDirectParentOf(*identifier); }
116
117            bool isA(const OrxonoxClass* object);
118            bool isExactlyA(const OrxonoxClass* object);
119            bool isChildOf(const OrxonoxClass* object);
120            bool isDirectChildOf(const OrxonoxClass* object);
121            bool isParentOf(const OrxonoxClass* object);
122            bool isDirectParentOf(const OrxonoxClass* object);
123
124            virtual void clone(OrxonoxClass*& item) {}
125
126            /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
127            inline unsigned int getReferenceCount() const
128                { return this->referenceCount_; }
129
130            /**
131            @brief
132                Returns a valid pointer of any derived type that is
133                registered in the class hierarchy.
134            @return
135                Returns NULL if the no pointer was found.
136            */
137            FORCEINLINE void* getDerivedPointer(unsigned int classID)
138            {
139                for (int i = this->objectPointers_.size() - 1; i >= 0; --i)
140                {
141                    if (this->objectPointers_[i].first == classID)
142                        return this->objectPointers_[i].second;
143                }
144                return NULL;
145            }
146
147            /// Version of getDerivedPointer with template
148            template <class T> FORCEINLINE T* getDerivedPointer(unsigned int classID)
149            {   return static_cast<T*>(this->getDerivedPointer(classID));   }
150            /// Const version of getDerivedPointer with template
151            template <class T> FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
152            {   return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);   }
153
154        protected:
155            /// 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 prevent destruction.
156            virtual void preDestroy() {}
157
158        private:
159            /// Increments the reference counter (for smart pointers).
160            inline void incrementReferenceCount()
161                { ++this->referenceCount_; }
162            /// Decrements the reference counter (for smart pointers).
163            inline void decrementReferenceCount()
164            {
165                --this->referenceCount_;
166                if (this->referenceCount_ == 0 && this->requestedDestruction_)
167                    this->destroy();
168            }
169
170            /// Register a destruction listener (for example a weak pointer which points to this object).
171            inline void registerDestructionListener(DestructionListener* pointer)
172                { this->destructionListeners_.insert(pointer); }
173            /// Unegister a destruction listener (for example a weak pointer which pointed to this object before).
174            inline void unregisterDestructionListener(DestructionListener* pointer)
175                { this->destructionListeners_.erase(pointer); }
176
177            Identifier* identifier_;                                //!< The Identifier of the object
178            std::set<const Identifier*>* parents_;                  //!< List of all parents of the object
179            MetaObjectList* metaList_;                              //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
180            int referenceCount_;                                    //!< Counts the references from smart pointers to this object
181            bool requestedDestruction_;                             //!< Becomes true after someone called delete on this object
182            std::set<DestructionListener*> destructionListeners_;   //!< All destruction listeners (for example weak pointers which point to this object and like to get notified if it dies)
183
184            /// 'Fast map' that holds this-pointers of all derived types
185            std::vector<std::pair<unsigned int, void*> > objectPointers_;
186    };
187
188    /**
189        @brief This listener is used to inform weak pointers if an object of type OrxonoxClass gets destroyed.
190    */
191    class _CoreExport DestructionListener
192    {
193        friend class OrxonoxClass;
194
195        protected:
196            virtual ~DestructionListener() {}
197
198            inline void registerAsDestructionListener(OrxonoxClass* object)
199                { if (object) { object->registerDestructionListener(this); } }
200            inline void unregisterAsDestructionListener(OrxonoxClass* object)
201                { if (object) { object->unregisterDestructionListener(this); } }
202
203            virtual void objectDeleted() = 0;
204    };
205
206    SUPER_FUNCTION(11, OrxonoxClass, clone, false);
207}
208
209#endif /* _OrxonoxClass_H__ */
Note: See TracBrowser for help on using the repository browser.