source: trunk/src/nrEngine/Engine.cpp @ 63

Revision 63, 8.9 KB checked in by art, 11 years ago (diff)
  • small changes in the Kernel and Engine, now Engine do stop the kernel when releasing and let kernel run one tick, so that all tasks can stop before removed
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 <nrEngine/Engine.h>
15#include <nrEngine/Kernel.h>
16#include <nrEngine/Clock.h>
17#include <nrEngine/Profiler.h>
18#include <nrEngine/ResourceManager.h>
19#include <nrEngine/PluginLoader.h>
20#include <nrEngine/FileStreamLoader.h>
21#include <nrEngine/EventManager.h>
22#include <nrEngine/ScriptEngine.h>
23#include <nrEngine/ScriptLoader.h>
24#include <nrEngine/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, (char*)"Log");
77                return _logger;
78        }
79
80        //--------------------------------------------------------------------------
81         Kernel* Engine::sKernel()
82        {
83                valid(_kernel, (char*)"Kernel");
84                return _kernel;
85        }
86
87        //--------------------------------------------------------------------------
88         Clock* Engine::sClock()
89        {
90                valid(_clock, (char*)"Clock");
91                return _clock;
92        }
93
94        //--------------------------------------------------------------------------
95         Profiler* Engine::sProfiler()
96        {
97                valid(_profiler, (char*)"Profiler");
98                return _profiler;
99        }
100
101        //--------------------------------------------------------------------------
102         ResourceManager* Engine::sResourceManager()
103        {
104                valid(_resmgr, (char*)"ResourceManager");
105                return _resmgr;
106        }
107
108        //--------------------------------------------------------------------------
109         EventManager* Engine::sEventManager()
110        {
111                valid(_event, (char*)"EventManager");
112                return _event;
113        }
114
115        //--------------------------------------------------------------------------
116         ScriptEngine* Engine::sScriptEngine()
117        {
118                valid(_script, (char*)"ScriptEngine");
119                return _script;
120        }
121
122        //--------------------------------------------------------------------------
123        PropertyManager* Engine::sPropertyManager()
124        {
125                valid(_propmgr, (char*)"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        stopEngine();
172
173                // remove default scripting methods
174                DefaultScriptingFunctions::delMethods();
175
176                // remove the manager
177                delete _resmgr;
178
179                // delete the clock
180                delete _clock;
181
182                // delete the kernel
183                delete _kernel;
184
185                // delete the scripting engine
186                delete _script;
187
188                // delete the event system
189                delete _event;
190
191                // remove property manager
192                delete _propmgr;
193
194                // remove profiler
195                delete _profiler;
196
197                // delete the log system
198                delete _logger;
199
200        }
201
202        //------------------------------------------------------------------------
203        bool Engine::initializeLog(const std::string& logPath)
204        {
205                return _logger->initialize(logPath) == OK;
206        }
207
208        //------------------------------------------------------------------------
209        void Engine::stopEngine()
210        {
211                // give log information
212                _logger->log(Log::LOG_ENGINE, (char*)"nrEngine stopped");
213
214                // stop kernel tasks
215                _kernel->StopExecution();
216        _kernel->OneTick();
217        }
218        //------------------------------------------------------------------------
219        bool Engine::initializeEngine()
220        {
221                // give some info about the underlying engine
222                NR_Log(Log::LOG_ENGINE | Log::LOG_CONSOLE | Log::LOG_KERNEL, (char*)"nrEngine v%s - %s", convertVersionToString(nrEngineVersion).c_str(), NR_VERSION_NAME);
223
224                // initialize the clock
225                SharedPtr<TimeSource> timeSource(new TimeSource());
226
227                // initialize profiler singleton
228                _profiler = (new Profiler(timeSource));
229                if (_profiler == NULL)
230                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, (char*)"Profiler singleton could not be created. Probably memory is full");
231
232                // now add the clock into kernel
233                _clock->setTimeSource(timeSource);
234                _clock->setTaskType(TASK_SYSTEM);
235                _kernel->AddTask(SharedPtr<ITask>(_clock, null_deleter()), ORDER_SYS_FIRST);
236
237                // initialize resource manager singleton
238                _event = (new EventManager());
239                if (_event == NULL)
240                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, (char*)"Event manager singleton could not be created. Probably memory is full");
241
242                _event->createChannel(NR_DEFAULT_EVENT_CHANNEL);
243                _event->setTaskType(TASK_SYSTEM);
244                _kernel->AddTask(SharedPtr<ITask>(_event, null_deleter()), ORDER_SYS_SECOND);
245
246                // initialise default scripting methods
247                DefaultScriptingFunctions::addMethods();
248
249                // initialize resource manager singleton
250                _resmgr = (new ResourceManager());
251                if (_resmgr == NULL)
252                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, (char*)"Resource manager singleton could not be created. Probably memory is full");
253
254                // Add the file reading functionality
255                ResourceLoader fileLoader (new FileStreamLoader());
256                _resmgr->registerLoader((char*)"FileStreamLoader", fileLoader);
257
258                // create an instance of plugin loader and add it to the resource manager
259                ResourceLoader loader ( new PluginLoader() );
260                _resmgr->registerLoader((char*)"PluginLoader", loader);
261
262                // create simple scripting language instancies
263                ResourceLoader scriptLoader( new ScriptLoader() );
264                _resmgr->registerLoader((char*)"ScriptLoader", scriptLoader);
265
266                return true;
267        }
268
269        //------------------------------------------------------------------------
270        void Engine::runEngine()
271        {
272
273                // log info
274                _logger->log(Log::LOG_ENGINE, (char*)"nrEngine started");
275
276                // start the kernel
277                _kernel->Execute();
278
279        }
280
281        //------------------------------------------------------------------------
282        void Engine::updateEngine()
283        {
284                // update the kernel
285                _kernel->OneTick();
286        }
287
288
289        //------------------------------------------------------------------------
290        bool Engine::loadPlugin(const std::string& path, const std::string& file, const std::string& name)
291        {
292                // check if the engine is initialized
293                if (_resmgr == NULL)
294                {
295                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, (char*)"Engine was not initialized properly");
296                        return false;
297                }
298
299                // try to load the resource and check for the error code
300                IResourcePtr plg = _resmgr->loadResource(name, (char*)"Plugins", path + file, (char*)"Plugin");
301
302                return true;
303        }
304
305
306        //------------------------------------------------------------------------
307        //Plugin getPlugin(const std::string& name){
308
309        //}
310
311}; // end namespace
312
Note: See TracBrowser for help on using the repository browser.