Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/presentation3/src/libraries/core/Core.cc @ 7155

Last change on this file since 7155 was 6994, checked in by scheusso, 15 years ago

merged skybox2 branch to presentation merger branch

  • Property svn:eol-style set to native
File size: 12.7 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 *      Reto Grieder
25 *   Co-authors:
26 *      ...
27 *
28 */
29
30/**
31@file
32@brief
33    Implementation of the Core singleton with its global variables (avoids boost include)
34*/
35
36#include "Core.h"
37
38#include <cassert>
39#include <vector>
40
41#ifdef ORXONOX_PLATFORM_WINDOWS
42#  ifndef WIN32_LEAN_AND_MEAN
43#    define WIN32_LEAN_AND_MEAN
44#  endif
45#  include <windows.h>
46#  undef min
47#  undef max
48#endif
49
50#include "util/Clock.h"
51#include "util/Debug.h"
52#include "util/Exception.h"
53#include "util/Scope.h"
54#include "util/SignalHandler.h"
55#include "PathConfig.h"
56#include "CommandExecutor.h"
57#include "CommandLineParser.h"
58#include "ConfigFileManager.h"
59#include "ConfigValueIncludes.h"
60#include "CoreIncludes.h"
61#include "DynLibManager.h"
62#include "GameMode.h"
63#include "GraphicsManager.h"
64#include "GUIManager.h"
65#include "Identifier.h"
66#include "Language.h"
67#include "IOConsole.h"
68#include "LuaState.h"
69#include "ScopedSingletonManager.h"
70#include "TclBind.h"
71#include "TclThreadManager.h"
72#include "input/InputManager.h"
73
74namespace orxonox
75{
76    //! Static pointer to the singleton
77    Core* Core::singletonPtr_s  = 0;
78
79    SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
80    SetCommandLineSwitch(noIOConsole).information("Use this if you don't want to use the IOConsole (for instance for Lua debugging)");
81
82#ifdef ORXONOX_PLATFORM_WINDOWS
83    SetCommandLineArgument(limitToCPU, 1).information("Limits the program to one CPU/core (1, 2, 3, etc.). Default is the first core (faster than off)");
84#endif
85
86    Core::Core(const std::string& cmdLine)
87        // Cleanup guard for identifier destruction (incl. XMLPort, configValues, consoleCommands)
88        : identifierDestroyer_(Identifier::destroyAllIdentifiers)
89        // Cleanup guard for external console commands that don't belong to an Identifier
90        , consoleCommandDestroyer_(CommandExecutor::destroyExternalCommands)
91        , bGraphicsLoaded_(false)
92        , bStartIOConsole_(true)
93    {
94        // Set the hard coded fixed paths
95        this->pathConfig_.reset(new PathConfig());
96
97        // Create a new dynamic library manager
98        this->dynLibManager_.reset(new DynLibManager());
99
100        // Load modules
101        const std::vector<std::string>& modulePaths = this->pathConfig_->getModulePaths();
102        for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
103        {
104            try
105            {
106                this->dynLibManager_->load(*it);
107            }
108            catch (...)
109            {
110                COUT(1) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << std::endl;
111            }
112        }
113
114        // Parse command line arguments AFTER the modules have been loaded (static code!)
115        CommandLineParser::parseCommandLine(cmdLine);
116
117        // Set configurable paths like log, config and media
118        this->pathConfig_->setConfigurablePaths();
119
120        // create a signal handler (only active for Linux)
121        // This call is placed as soon as possible, but after the directories are set
122        this->signalHandler_.reset(new SignalHandler());
123        this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
124
125        // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% (Windows) was used
126        OutputHandler::getInstance().setLogPath(PathConfig::getLogPathString());
127
128        // Parse additional options file now that we know its path
129        CommandLineParser::parseFile();
130
131#ifdef ORXONOX_PLATFORM_WINDOWS
132        // limit the main thread to the first core so that QueryPerformanceCounter doesn't jump
133        // do this after ogre has initialised. Somehow Ogre changes the settings again (not through
134        // the timer though).
135        int limitToCPU = CommandLineParser::getValue("limitToCPU");
136        if (limitToCPU > 0)
137            setThreadAffinity(static_cast<unsigned int>(limitToCPU));
138#endif
139
140        // Manage ini files and set the default settings file (usually orxonox.ini)
141        this->configFileManager_.reset(new ConfigFileManager());
142        this->configFileManager_->setFilename(ConfigFileType::Settings,
143            CommandLineParser::getValue("settingsFile").getString());
144
145        // Required as well for the config values
146        this->languageInstance_.reset(new Language());
147
148        // Do this soon after the ConfigFileManager has been created to open up the
149        // possibility to configure everything below here
150        ClassIdentifier<Core>::getIdentifier("Core")->initialiseObject(this, "Core", true);
151        this->setConfigValues();
152
153        // create persistent io console
154        if (CommandLineParser::getValue("noIOConsole").getBool())
155        {
156            ModifyConfigValue(bStartIOConsole_, tset, false);
157        }
158        if (this->bStartIOConsole_)
159            this->ioConsole_.reset(new IOConsole());
160
161        // creates the class hierarchy for all classes with factories
162        Identifier::createClassHierarchy();
163
164        // Load OGRE excluding the renderer and the render window
165        this->graphicsManager_.reset(new GraphicsManager(false));
166
167        // initialise Tcl
168        this->tclBind_.reset(new TclBind(PathConfig::getDataPathString()));
169        this->tclThreadManager_.reset(new TclThreadManager(tclBind_->getTclInterpreter()));
170
171        // Create singletons that always exist (in other libraries)
172        this->rootScope_.reset(new Scope<ScopeID::Root>());
173    }
174
175    /**
176    @brief
177        All destruction code is handled by scoped_ptrs and ScopeGuards.
178    */
179    Core::~Core()
180    {
181        // Remove us from the object lists again to avoid problems when destroying them
182        this->unregisterObject();
183    }
184
185    //! Function to collect the SetConfigValue-macro calls.
186    void Core::setConfigValues()
187    {
188#ifdef ORXONOX_RELEASE
189        const unsigned int defaultLevelLogFile = 3;
190#else
191        const unsigned int defaultLevelLogFile = 4;
192#endif
193        setConfigValueGeneric(this, &this->softDebugLevelLogFile_, ConfigFileType::Settings, "OutputHandler", "softDebugLevelLogFile", defaultLevelLogFile)
194            .description("The maximum level of debug output shown in the log file");
195        OutputHandler::getInstance().setSoftDebugLevel(OutputHandler::logFileOutputListenerName_s, this->softDebugLevelLogFile_);
196
197        SetConfigValue(language_, Language::getInstance().defaultLanguage_)
198            .description("The language of the in game text")
199            .callback(this, &Core::languageChanged);
200        SetConfigValue(bInitRandomNumberGenerator_, true)
201            .description("If true, all random actions are different each time you start the game")
202            .callback(this, &Core::initRandomNumberGenerator);
203        SetConfigValue(bStartIOConsole_, true)
204            .description("Set to false if you don't want to use the IOConsole (for Lua debugging for instance)");
205    }
206
207    //! Callback function if the language has changed.
208    void Core::languageChanged()
209    {
210        // Read the translation file after the language was configured
211        Language::getInstance().readTranslatedLanguageFile();
212    }
213
214    void Core::initRandomNumberGenerator()
215    {
216        static bool bInitialized = false;
217        if (!bInitialized && this->bInitRandomNumberGenerator_)
218        {
219            srand(static_cast<unsigned int>(time(0)));
220            rand();
221            bInitialized = true;
222        }
223    }
224
225    void Core::loadGraphics()
226    {
227        // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
228        Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
229
230        // Upgrade OGRE to receive a render window
231        graphicsManager_->upgradeToGraphics();
232
233        // Calls the InputManager which sets up the input devices.
234        inputManager_.reset(new InputManager());
235
236        // Load the CEGUI interface
237        guiManager_.reset(new GUIManager(inputManager_->getMousePosition()));
238
239        bGraphicsLoaded_ = true;
240        GameMode::bShowsGraphics_s = true;
241
242        // Load some sort of a debug overlay (only denoted by its name, "debug.oxo")
243        graphicsManager_->loadDebugOverlay();
244
245        // Create singletons associated with graphics (in other libraries)
246        graphicsScope_.reset(new Scope<ScopeID::Graphics>());
247
248        unloader.Dismiss();
249    }
250
251    void Core::unloadGraphics()
252    {
253        this->graphicsScope_.reset();
254        this->guiManager_.reset();
255        this->inputManager_.reset();
256        this->graphicsManager_.reset();
257
258        // Load Ogre::Root again, but without the render system
259        try
260            { this->graphicsManager_.reset(new GraphicsManager(false)); }
261        catch (...)
262        {
263            COUT(0) << "An exception occurred during 'unloadGraphics':" << Exception::handleMessage() << std::endl
264                    << "Another exception might be being handled which may lead to undefined behaviour!" << std::endl
265                    << "Terminating the program." << std::endl;
266            abort();
267        }
268
269        bGraphicsLoaded_ = false;
270        GameMode::bShowsGraphics_s = false;
271    }
272
273    //! Sets the language in the config-file back to the default.
274    void Core::resetLanguage()
275    {
276        ResetConfigValue(language_);
277    }
278
279    /**
280    @note
281        The code of this function has been copied and adjusted from OGRE, an open source graphics engine.
282            (Object-oriented Graphics Rendering Engine)
283        For the latest info, see http://www.ogre3d.org/
284
285        Copyright (c) 2000-2008 Torus Knot Software Ltd
286
287        OGRE is licensed under the LGPL. For more info, see OGRE license.
288    */
289    void Core::setThreadAffinity(int limitToCPU)
290    {
291#ifdef ORXONOX_PLATFORM_WINDOWS
292
293        if (limitToCPU <= 0)
294            return;
295
296        unsigned int coreNr = limitToCPU - 1;
297        // Get the current process core mask
298        DWORD procMask;
299        DWORD sysMask;
300#  if _MSC_VER >= 1400 && defined (_M_X64)
301        GetProcessAffinityMask(GetCurrentProcess(), (PDWORD_PTR)&procMask, (PDWORD_PTR)&sysMask);
302#  else
303        GetProcessAffinityMask(GetCurrentProcess(), &procMask, &sysMask);
304#  endif
305
306        // If procMask is 0, consider there is only one core available
307        // (using 0 as procMask will cause an infinite loop below)
308        if (procMask == 0)
309            procMask = 1;
310
311        // if the core specified with coreNr is not available, take the lowest one
312        if (!(procMask & (1 << coreNr)))
313            coreNr = 0;
314
315        // Find the lowest core that this process uses and coreNr suggests
316        DWORD threadMask = 1;
317        while ((threadMask & procMask) == 0 || (threadMask < (1u << coreNr)))
318            threadMask <<= 1;
319
320        // Set affinity to the first core
321        SetThreadAffinityMask(GetCurrentThread(), threadMask);
322#endif
323    }
324
325    void Core::preUpdate(const Clock& time)
326    {
327        // Update singletons before general ticking
328        ScopedSingletonManager::preUpdate<ScopeID::Root>(time);
329        if (this->bGraphicsLoaded_)
330        {
331            // Process input events
332            this->inputManager_->preUpdate(time);
333            // Update GUI
334            this->guiManager_->preUpdate(time);
335            // Update singletons before general ticking
336            ScopedSingletonManager::preUpdate<ScopeID::Graphics>(time);
337        }
338        // Process console events and status line
339        if (this->ioConsole_ != NULL)
340            this->ioConsole_->preUpdate(time);
341        // Process thread commands
342        this->tclThreadManager_->preUpdate(time);
343    }
344
345    void Core::postUpdate(const Clock& time)
346    {
347        // Update singletons just before rendering
348        ScopedSingletonManager::postUpdate<ScopeID::Root>(time);
349        if (this->bGraphicsLoaded_)
350        {
351            // Update singletons just before rendering
352            ScopedSingletonManager::postUpdate<ScopeID::Graphics>(time);
353            // Render (doesn't throw)
354            this->graphicsManager_->postUpdate(time);
355        }
356    }
357}
Note: See TracBrowser for help on using the repository browser.