source: nrEngine/src/Engine.cpp @ 31

Revision 31, 8.7 KB checked in by art, 12 years ago (diff)

dynamicResourceManagment Plugin added.

TODO: change file association list of resources. This is required
by the drm plugin to be able to reload the resource as soon as one of
the associated file changes.

Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13
14#include "Engine.h"
15#include "Kernel.h"
16#include "Clock.h"
17#include "Profiler.h"
18#include "ResourceManager.h"
19#include "PluginLoader.h"
20#include "FileStreamLoader.h"
21#include "EventManager.h"
22#include "ScriptEngine.h"
23#include "ScriptLoader.h"
24#include "PropertyManager.h"
25#include "DefaultScriptingFunctions.cpp"
26
27namespace nrEngine{
28
29        // Here we store the instances of singletons
30        SharedPtr<Engine>       Engine::sSingleton;
31        Log*                            Engine::_logger = NULL;
32        Kernel*                         Engine::_kernel = NULL;
33        Clock*                          Engine::_clock = NULL;
34        Profiler*                       Engine::_profiler = NULL;
35        ResourceManager*        Engine::_resmgr = NULL;
36        ScriptEngine*           Engine::_script = NULL;
37        EventManager*           Engine::_event = NULL;
38        PropertyManager*        Engine::_propmgr = NULL;
39
40        //--------------------------------------------------------------------------
41        bool Engine::valid(void* p, char* name, bool showWarn)
42        {
43                if (p == NULL && showWarn)
44                {
45                        printf("Warning: Given pointer of type %s is not valid!\n", name);
46                        return false;
47                }
48
49                return p != NULL;
50        }
51
52        //------------------------------------------------------------------------
53        Engine* Engine::instance(bool brelease)
54        {
55                if (brelease && valid()){
56                        sSingleton.reset();
57                        return NULL;
58                }else if (!brelease && !valid()){
59                        sSingleton.reset(new Engine());
60                }
61                return sSingleton.get();
62        }
63
64        //------------------------------------------------------------------------
65        void Engine::release()
66        {
67                if (valid())
68                {
69                        sSingleton.reset();
70                }
71        }
72
73        //--------------------------------------------------------------------------
74         Log* Engine::sLog()
75        {
76                valid(_logger, "Log");
77                return _logger;
78        }
79
80        //--------------------------------------------------------------------------
81         Kernel* Engine::sKernel()
82        {
83                valid(_kernel, "Kernel");
84                return _kernel;
85        }
86
87        //--------------------------------------------------------------------------
88         Clock* Engine::sClock()
89        {
90                valid(_clock, "Clock");
91                return _clock;
92        }
93
94        //--------------------------------------------------------------------------
95         Profiler* Engine::sProfiler()
96        {
97                valid(_profiler, "Profiler");
98                return _profiler;
99        }
100
101        //--------------------------------------------------------------------------
102         ResourceManager* Engine::sResourceManager()
103        {
104                valid(_resmgr, "ResourceManager");
105                return _resmgr;
106        }
107
108        //--------------------------------------------------------------------------
109         EventManager* Engine::sEventManager()
110        {
111                valid(_event, "EventManager");
112                return _event;
113        }
114
115        //--------------------------------------------------------------------------
116         ScriptEngine* Engine::sScriptEngine()
117        {
118                valid(_script, "ScriptEngine");
119                return _script;
120        }
121
122        //--------------------------------------------------------------------------
123        PropertyManager* Engine::sPropertyManager()
124        {
125                valid(_propmgr, "PropertyManager");
126                return _propmgr;
127        }
128
129        //------------------------------------------------------------------------
130        Engine::Engine()
131        {
132                // first of all create the log system, so we get valid pointer
133                _logger = (new Log());
134                if (_logger == NULL)
135                {
136                        NR_EXCEPT(OUT_OF_MEMORY, "Log system could not be created. Probably memory is full", "Engine::Engine()");
137                }
138               
139                // create property manager
140                _propmgr = (new PropertyManager());
141                if (_propmgr == NULL)
142                {
143                        NR_EXCEPT(OUT_OF_MEMORY, "PropertyManager could not been created. Check if the memory is not full", "Engine::Engine()");
144                }
145
146                // initialize the scripting engine
147                _script = (new ScriptEngine());
148                if (_script == NULL)
149                {
150                        NR_EXCEPT(OUT_OF_MEMORY, "Scripting Engine could not been created. Check if the memory is not full", "Engine::Engine()");
151                }
152
153                // now create a kernel subsystem
154                _kernel = (new Kernel());
155                if (_kernel == NULL)
156                {
157                        NR_EXCEPT(OUT_OF_MEMORY, "Kernel system could not be created. Probably memory is full", "Engine::Engine()");
158                }
159
160                // initialize the clock
161                _clock = (new Clock());
162                if (_clock == NULL)
163                {
164                        NR_EXCEPT(OUT_OF_MEMORY, "Clock could not be created. Probably memory is full", "Engine::Engine()");
165                }
166        }
167
168        //------------------------------------------------------------------------
169        Engine::~Engine()
170        {
171                // remove default scripting methods
172                DefaultScriptingFunctions::delMethods();
173
174                // remove the manager
175                delete _resmgr;
176
177                // delete the clock
178                delete _clock;
179
180                // delete the kernel
181                delete _kernel;
182
183                // delete the scripting engine
184                delete _script;
185
186                // delete the event system
187                delete _event;
188               
189                // remove property manager
190                delete _propmgr;
191               
192                // remove profiler
193                delete _profiler;
194
195                // delete the log system
196                delete _logger;
197
198        }
199
200        //------------------------------------------------------------------------
201        bool Engine::initializeLog(const std::string& logPath)
202        {
203                return _logger->initialize(logPath) == OK;
204        }
205
206        //------------------------------------------------------------------------
207        void Engine::stopEngine()
208        {
209                // give log information
210                _logger->log(Log::LOG_ENGINE, "nrEngine stopped");
211
212                // stop kernel tasks
213                _kernel->StopExecution();
214
215        }
216        //------------------------------------------------------------------------
217        bool Engine::initializeEngine()
218        {
219                // give some info about the underlying engine
220                NR_Log(Log::LOG_ENGINE | Log::LOG_CONSOLE | Log::LOG_KERNEL, "nrEngine v%s - %s", convertVersionToString(nrEngineVersion).c_str(), NR_VERSION_NAME);
221               
222                // initialize the clock
223                SharedPtr<TimeSource> timeSource(new TimeSource());
224
225                // initialize profiler singleton
226                _profiler = (new Profiler(timeSource));
227                if (_profiler == NULL)
228                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Profiler singleton could not be created. Probably memory is full");
229
230                // now add the clock into kernel
231                _clock->setTimeSource(timeSource);
232                _clock->setTaskType(TASK_SYSTEM);
233                _kernel->AddTask(SharedPtr<ITask>(_clock, null_deleter()), ORDER_SYS_FIRST);
234
235                // initialize resource manager singleton
236                _event = (new EventManager());
237                if (_event == NULL)
238                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Event manager singleton could not be created. Probably memory is full");
239
240                _event->createChannel(NR_DEFAULT_EVENT_CHANNEL);
241                _event->setTaskType(TASK_SYSTEM);
242                _kernel->AddTask(SharedPtr<ITask>(_event, null_deleter()), ORDER_SYS_SECOND);
243
244                // initialise default scripting methods
245                DefaultScriptingFunctions::addMethods();
246               
247                // initialize resource manager singleton
248                _resmgr = (new ResourceManager());
249                if (_resmgr == NULL)
250                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Resource manager singleton could not be created. Probably memory is full");
251
252                // Add the file reading functionality
253                ResourceLoader fileLoader (new FileStreamLoader());
254                _resmgr->registerLoader("FileStreamLoader", fileLoader);
255
256                // create an instance of plugin loader and add it to the resource manager
257                ResourceLoader loader ( new PluginLoader() );
258                _resmgr->registerLoader("PluginLoader", loader);
259
260                // create simple scripting language instancies
261                ResourceLoader scriptLoader( new ScriptLoader() );
262                _resmgr->registerLoader("ScriptLoader", scriptLoader);
263
264                return true;
265        }
266
267        //------------------------------------------------------------------------
268        void Engine::runEngine()
269        {
270
271                // log info
272                _logger->log(Log::LOG_ENGINE, "nrEngine started");
273
274                // start the kernel
275                _kernel->Execute();
276
277        }
278
279        //------------------------------------------------------------------------
280        void Engine::updateEngine()
281        {
282                // update the kernel
283                _kernel->OneTick();
284        }
285
286
287        //------------------------------------------------------------------------
288        bool Engine::loadPlugin(const std::string& path, const std::string& file, const std::string& name)
289        {
290                // check if the engine is initialized
291                if (_resmgr == NULL)
292                {
293                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Engine was not initialized properly");
294                        return false;
295                }
296
297                // try to load the resource and check for the error code
298                IResourcePtr plg = _resmgr->loadResource(name, "Plugins", path + file, "Plugin");
299
300                return true;
301        }
302
303       
304        //------------------------------------------------------------------------
305        //Plugin getPlugin(const std::string& name){
306
307        //}
308       
309}; // end namespace
310
Note: See TracBrowser for help on using the repository browser.