source: nrEngine/src/Engine.cpp @ 1

Revision 1, 10.1 KB checked in by art, 13 years ago (diff)
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
25namespace nrEngine{
26
27        // Here we store the instances of singletons
28        SharedPtr<Engine>       Engine::sSingleton;
29        Log*                            Engine::_logger = NULL;
30        Kernel*                         Engine::_kernel = NULL;
31        Clock*                          Engine::_clock = NULL;
32        Profiler*                       Engine::_profiler = NULL;
33        ResourceManager*        Engine::_resmgr = NULL;
34        ScriptEngine*           Engine::_script = NULL;
35        EventManager*           Engine::_event = NULL;
36
37        //--------------------------------------------------------------------------
38        bool Engine::valid(void* p, char* name, bool showWarn)
39        {
40                if (p == NULL && showWarn)
41                {
42                        printf("Warning: Given pointer of type %s is not valid!\n", name);
43                        return false;
44                }
45
46                return p != NULL;
47        }
48
49        //------------------------------------------------------------------------
50        Engine* Engine::instance(bool brelease)
51        {
52                if (brelease && valid()){
53                        sSingleton.reset();
54                        return NULL;
55                }else if (!brelease && !valid()){
56                        sSingleton.reset(new Engine());
57                }
58                return sSingleton.get();
59        }
60
61        //------------------------------------------------------------------------
62        void Engine::release()
63        {
64                if (valid())
65                {
66                        sSingleton.reset();
67                }
68        }
69
70        //--------------------------------------------------------------------------
71         Log* Engine::sLog()
72        {
73                valid(_logger, "Log");
74                return _logger;
75        }
76
77        //--------------------------------------------------------------------------
78         Kernel* Engine::sKernel()
79        {
80                valid(_kernel, "Kernel");
81                return _kernel;
82        }
83
84        //--------------------------------------------------------------------------
85         Clock* Engine::sClock()
86        {
87                valid(_clock, "Clock");
88                return _clock;
89        }
90
91        //--------------------------------------------------------------------------
92         Profiler* Engine::sProfiler()
93        {
94                valid(_profiler, "Profiler");
95                return _profiler;
96        }
97
98        //--------------------------------------------------------------------------
99         ResourceManager* Engine::sResourceManager()
100        {
101                valid(_resmgr, "ResourceManager");
102                return _resmgr;
103        }
104
105        //--------------------------------------------------------------------------
106         EventManager* Engine::sEventManager()
107        {
108                valid(_event, "EventManager");
109                return _event;
110        }
111
112        //--------------------------------------------------------------------------
113         ScriptEngine* Engine::sScriptEngine()
114        {
115                valid(_script, "ScriptEngine");
116                return _script;
117        }
118
119        //------------------------------------------------------------------------
120        Engine::Engine()
121        {
122                // first of all create the log system, so we get valid pointer
123                _logger = (new Log());
124                if (_logger == NULL)
125                {
126                        NR_EXCEPT(OUT_OF_MEMORY, "Log system could not be created. Probably memory is full", "Engine::Engine()");
127                }
128
129                // initialize the scripting engine
130                _script = (new ScriptEngine());
131                if (_script == NULL)
132                {
133                        NR_EXCEPT(OUT_OF_MEMORY, "Scripting Engine could not been created. Check if the memory is not full", "Engine::Engine()");
134                }
135
136                // now create a kernel subsystem
137                _kernel = (new Kernel());
138                if (_kernel == NULL)
139                {
140                        NR_EXCEPT(OUT_OF_MEMORY, "Kernel system could not be created. Probably memory is full", "Engine::Engine()");
141                }
142
143                // initialize the clock
144                _clock = (new Clock());
145                if (_clock == NULL)
146                {
147                        NR_EXCEPT(OUT_OF_MEMORY, "Clock could not be created. Probably memory is full", "Engine::Engine()");
148                }
149        }
150
151        //------------------------------------------------------------------------
152        Engine::~Engine()
153        {
154
155                // remove the manager
156                delete _resmgr;
157
158                // delete the clock
159                delete _clock;
160
161                // delete the kernel
162                delete _kernel;
163
164                // delete the scripting engine
165                delete _script;
166
167                // delete the event system
168                delete _event;
169               
170                // remove profiler
171                delete _profiler;
172
173                // delete the log system
174                delete _logger;
175
176        }
177
178        //------------------------------------------------------------------------
179        bool Engine::initializeLog(const std::string& logPath)
180        {
181                return _logger->initialize(logPath) == OK;
182        }
183
184        //------------------------------------------------------------------------
185        void Engine::stopEngine()
186        {
187                // give log information
188                _logger->log(Log::LOG_ENGINE, "nrEngine stopped");
189
190                // stop kernel tasks
191                _kernel->StopExecution();
192
193        }
194        //------------------------------------------------------------------------
195        bool Engine::initializeEngine()
196        {
197                // give some info about the underlying engine
198                NR_Log(Log::LOG_ENGINE | Log::LOG_CONSOLE | Log::LOG_KERNEL, "nrEngine v%s - %s", convertVersionToString(nrEngineVersion).c_str(), NR_VERSION_NAME);
199
200                // initialize the clock
201                SharedPtr<TimeSource> timeSource(new TimeSource());
202
203                // initialize profiler singleton
204                _profiler = (new Profiler(timeSource));
205                if (_profiler == NULL)
206                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Profiler singleton could not be created. Probably memory is full");
207
208                // now add the clock into kernel
209                _clock->setTimeSource(timeSource);
210                _clock->setTaskType(TASK_SYSTEM);
211                _kernel->AddTask(SharedPtr<ITask>(_clock, null_deleter()), ORDER_SYS_FIRST);
212
213                // initialize resource manager singleton
214                _event = (new EventManager());
215                if (_event == NULL)
216                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Event manager singleton could not be created. Probably memory is full");
217
218                _event->createChannel(NR_DEFAULT_EVENT_CHANNEL);
219                _event->setTaskType(TASK_SYSTEM);
220                _kernel->AddTask(SharedPtr<ITask>(_event, null_deleter()), ORDER_SYS_SECOND);
221
222                // initialize resource manager singleton
223                _resmgr = (new ResourceManager());
224                if (_resmgr == NULL)
225                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Resource manager singleton could not be created. Probably memory is full");
226
227                // Add the file reading functionality
228                ResourceLoader fileLoader (new FileStreamLoader());
229                _resmgr->registerLoader("FileStreamLoader", fileLoader);
230
231                // create an instance of plugin loader and add it to the resource manager
232                ResourceLoader loader ( new PluginLoader() );
233                _resmgr->registerLoader("PluginLoader", loader);
234
235                // create simple scripting language instancies
236                ResourceLoader scriptLoader( new ScriptLoader() );
237                _resmgr->registerLoader("ScriptLoader", scriptLoader);
238
239                return true;
240        }
241
242        //------------------------------------------------------------------------
243        void Engine::runEngine()
244        {
245
246                // log info
247                _logger->log(Log::LOG_ENGINE, "nrEngine started");
248
249                // start the kernel
250                _kernel->Execute();
251
252        }
253
254        //------------------------------------------------------------------------
255        void Engine::updateEngine()
256        {
257                // update the kernel
258                _kernel->OneTick();
259        }
260
261
262        //------------------------------------------------------------------------
263        bool Engine::loadPlugin(const std::string& path, const std::string& file, const std::string& name)
264        {
265                // check if the engine is initialized
266                if (_resmgr == NULL){
267                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Engine was not initialized properly");
268                        return false;
269                }
270
271                // try to load the resource and check for the error code
272                IResourcePtr plg = _resmgr->loadResource(name, "Plugins", path + file);
273
274                if (plg == NULL)
275                        return false;
276
277                return true;
278        }
279
280       
281        //------------------------------------------------------------------------
282        //Plugin getPlugin(const std::string& name){
283
284        //}
285
286
287}; // end namespace
288
289#if 0
290/**
291 * This function will convert the given nrResult number to the
292 * string describing it. e.g: NR_OK => "NR_OK"
293 *
294 * @param res - error code to be converted in string
295 * \ingroup engine
296 **/
297/*string        nrErrorGetShort(nrResult res){
298
299        char str[256];
300        sprintf(str, "%x", res);
301
302#define _ERROR(p) case p: sprintf(str, #p);break;
303
304        switch (res){
305
306_ERROR(NR_OK)
307_ERROR(NR_UNKNOWN_ERROR)
308_ERROR(NR_BAD_PARAMETERS)
309_ERROR(NR_OUT_OF_MEMORY)
310
311_ERROR(NR_FILE_ERROR)
312_ERROR(NR_FILE_NOT_FOUND)
313_ERROR(NR_FILE_ERROR_IN_LINE)
314
315_ERROR(NR_PROFILE_ERROR)
316_ERROR(NR_PROFILE_NOT_FOUND)
317_ERROR(NR_PROFILE_NOT_LOADED)
318_ERROR(NR_PROFILE_NOT_EXISTS)
319_ERROR(NR_PROFILE_ALREADY_EXISTS)
320
321_ERROR(NR_EXTENSION_ERROR)
322_ERROR(NR_EXTENSION_NOT_SUPPORTED)
323
324_ERROR(NR_VFS_ERROR)
325_ERROR(NR_VFS_ALREADY_OPEN)
326_ERROR(NR_VFS_CANNOT_OPEN)
327_ERROR(NR_VFS_CANNOT_CLOSE)
328_ERROR(NR_VFS_IS_NOT_OPEN)
329_ERROR(NR_VFS_FILE_NOT_FOUND)
330_ERROR(NR_VFS_FILE_NOT_OPEN)
331_ERROR(NR_VFS_FILE_END_REACHED)
332_ERROR(NR_VFS_FILE_READ_ERROR)
333_ERROR(NR_VFS_LINE_READ_ERROR)
334_ERROR(NR_VFS_SCAN_READ_ERROR)
335_ERROR(NR_VFS_SEEK_ERROR)
336
337_ERROR(NR_APP_ERROR)
338
339_ERROR(NR_LOG_ERROR)
340
341_ERROR(NR_SETTINGS_ERROR)
342_ERROR(NR_SETTINGS_VAR_ALREADY_REGISTERED)
343_ERROR(NR_SETTINGS_VAR_NOT_REGISTERED)
344
345_ERROR(NR_KERNEL_ERROR)
346_ERROR(NR_KERNEL_NO_TASK_FOUND)
347
348_ERROR(NR_TASK_ERROR)
349_ERROR(NR_TASK_NOT_READY)
350
351_ERROR(NR_CONSOLE_ERROR)
352_ERROR(NR_CONSOLE_ITEM_ALREADY_EXISTS)
353
354
355_ERROR(NR_TEX_ERROR)
356_ERROR(NR_TEX_INVALID_FORMAT)
357_ERROR(NR_TEX_NOT_CREATED_BEFORE)
358
359_ERROR(NR_CLOCK_ERROR)
360_ERROR(NR_CLOCK_OBSERVER_NOT_FOUND)
361_ERROR(NR_CLOCK_OBSERVER_ALREADY_ADDED)
362
363_ERROR(NR_FW_ERROR)
364_ERROR(NR_FW_CANNOT_INITIALIZE)
365_ERROR(NR_FW_FAILED_TO_RESIZE)
366_ERROR(NR_FW_INVALID_RC_ID)
367_ERROR(NR_FW_ALREADY_INIT)
368_ERROR(NR_FW_NOT_INITIALIZED)
369
370_ERROR(NR_RC_ERROR)
371_ERROR(NR_RC_CANNOT_SETUP_PIXEL_FORMAT)
372
373_ERROR(NR_ENGINE_ERROR)
374_ERROR(NR_ENGINE_YOU_MUST_CREATE_ENGINE_BEFORE)
375
376_ERROR(NR_RES_ERROR)
377_ERROR(NR_RES_LOADER_ALREADY_EXISTS)
378_ERROR(NR_RES_LOADER_NOT_REGISTERED)
379_ERROR(NR_RES_ALREADY_EXISTS)
380_ERROR(NR_RES_BAD_FILETYPE)
381_ERROR(NR_RES_CAN_NOT_LOAD_EMPTY)
382_ERROR(NR_RES_NOT_FOUND)
383_ERROR(NR_RES_LOADER_NOT_EXISTS )
384
385                default:
386                        sprintf(str,"%x", res);
387        }
388
389#undef _ERROR
390        return str;
391}*/
392#endif
Note: See TracBrowser for help on using the repository browser.