Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/pickups2/src/orxonox/gui/GUIManager.cc @ 3088

Last change on this file since 3088 was 2896, checked in by landauf, 16 years ago

Merged gui branch back to trunk.

I did 2 small changes in IngameManager.cc on line 777 and 888 (yes, really), because const_reverse_iterator strangely doesn't work on MinGW.

  • Property svn:eol-style set to native
File size: 11.4 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 *      Reto Grieder
24 *      Benjamin Knecht
25 *   Co-authors:
26 *
27 *
28 */
29
30/**
31    @file
32    @brief
33        Implementation of the GUIManager class.
34*/
35
36#include "OrxonoxStableHeaders.h"
37#include "GUIManager.h"
38
39#include <boost/filesystem/path.hpp>
40#include <OgreRenderWindow.h>
41#include <CEGUI.h>
42#include <CEGUIDefaultLogger.h>
43#include <ogreceguirenderer/OgreCEGUIRenderer.h>
44#include "SpecialConfig.h" // Configures the macro below
45#ifdef CEGUILUA_USE_INTERNAL_LIBRARY
46#   include <ceguilua/CEGUILua.h>
47#else
48#   include <CEGUILua.h>
49#endif
50
51#include "util/Exception.h"
52#include "core/ConsoleCommand.h"
53#include "core/Core.h"
54#include "core/Clock.h"
55#include "ToluaBindCore.h"
56#include "ToluaBindOrxonox.h"
57
58extern "C" {
59#include <lua.h>
60}
61
62namespace orxonox
63{
64    GUIManager* GUIManager::singletonRef_s = 0;
65
66    GUIManager::GUIManager()
67        : renderWindow_(0)
68        , guiRenderer_(0)
69        , resourceProvider_(0)
70        , scriptModule_(0)
71        , guiSystem_(0)
72        , state_(Uninitialised)
73    {
74        assert(singletonRef_s == 0);
75        singletonRef_s = this;
76    }
77
78    /**
79    @brief
80        Deconstructor of the GUIManager
81
82        Basically shuts down CEGUI and destroys the Lua engine and afterwards the interface to the Ogre engine.
83    */
84    GUIManager::~GUIManager()
85    {
86        if (guiSystem_)
87            delete guiSystem_;
88
89        if (scriptModule_)
90        {
91            // destroy our own tolua interfaces
92                lua_pushnil(luaState_);
93                lua_setglobal(luaState_, "Orxonox");
94                lua_pushnil(luaState_);
95                lua_setglobal(luaState_, "Core");
96            delete scriptModule_;
97        }
98
99        if (guiRenderer_)
100            delete guiRenderer_;
101
102        singletonRef_s = 0;
103    }
104
105    /**
106    @brief
107        Initialises the GUIManager by starting up CEGUI
108    @param renderWindow
109        Ogre's render window. Without this, the GUI cannot be displayed.
110    @return true if success, otherwise false
111
112        Before this call the GUIManager won't do anything, but can be accessed.
113
114        Creates the interface to Ogre, sets up the CEGUI renderer and the Lua script module together with the Lua engine.
115        The log is set up and connected to the CEGUILogger.
116        After Lua setup tolua++-elements are linked to Lua-state to give Lua access to C++-code.
117        Finally initial Lua code is executed (maybe we can do this with the CEGUI startup script automatically).
118    */
119    bool GUIManager::initialise(Ogre::RenderWindow* renderWindow)
120    {
121        using namespace CEGUI;
122        if (state_ == Uninitialised)
123        {
124            COUT(3) << "Initialising CEGUI." << std::endl;
125
126            try
127            {
128                // save the render window
129                renderWindow_ = renderWindow;
130
131                // Note: No SceneManager specified yet
132                this->guiRenderer_ = new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_OVERLAY, true, 3000);
133                this->resourceProvider_ = guiRenderer_->createResourceProvider();
134                this->resourceProvider_->setDefaultResourceGroup("GUI");
135
136                // setup scripting
137                this->scriptModule_ = new LuaScriptModule();
138                this->luaState_ = this->scriptModule_->getLuaState();
139
140                // Create our own logger to specify the filepath
141                boost::filesystem::path ceguiLogFilepath(Core::getLogPath() / "cegui.log");
142                this->ceguiLogger_ = new DefaultLogger();
143                this->ceguiLogger_->setLogFilename(ceguiLogFilepath.string());
144                // set the log level according to ours (translate by subtracting 1)
145                this->ceguiLogger_->setLoggingLevel(
146                    (LoggingLevel)(Core::getSoftDebugLevel(OutputHandler::LD_Logfile) - 1));
147
148                // create the CEGUI system singleton
149                this->guiSystem_ = new System(this->guiRenderer_, this->resourceProvider_, 0, this->scriptModule_);
150
151                // do this after 'new CEGUI::Sytem' because that creates the lua state in the first place
152                tolua_Core_open(this->scriptModule_->getLuaState());
153                tolua_Orxonox_open(this->scriptModule_->getLuaState());
154
155                // initialise the basic lua code
156                loadLuaCode();
157            }
158            catch (CEGUI::Exception& ex)
159            {
160#if CEGUI_VERSION_MAJOR == 0 && CEGUI_VERSION_MINOR < 6
161                throw GeneralException(ex.getMessage().c_str());
162#else
163                throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
164                    ex.getFileName().c_str(), ex.getName().c_str());
165#endif
166            }
167
168            state_ = Ready;
169        }
170
171        return true;
172    }
173
174    /**
175    @brief
176        Calls main Lua script
177    @todo
178        Replace loadGUI.lua with loadGUI_2.lua after merging this back to trunk.
179        However CEGUI is able to execute a startup script. We could maybe put this call in this startup code.
180
181        This function calls the main Lua script for our GUI.
182
183        Additionally we set the datapath variable in Lua. This is needed so Lua can access the data used for the GUI.
184    */
185    void GUIManager::loadLuaCode()
186    {
187        try
188        {
189            // call main Lua script
190            this->scriptModule_->executeScriptFile("loadGUI_2.lua", "GUI");
191            // set datapath for GUI data
192            lua_pushfstring(this->scriptModule_->getLuaState(), Core::getMediaPathString().c_str());
193            lua_setglobal(this->scriptModule_->getLuaState(), "datapath");
194        }
195        catch (CEGUI::Exception& ex)
196        {
197#if CEGUI_VERSION_MINOR < 6
198            throw GeneralException(ex.getMessage().c_str());
199#else
200            throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
201                ex.getFileName().c_str(), ex.getName().c_str());
202#endif
203        }
204    }
205
206    /**
207    @brief
208        used to tick the GUI
209    @param time
210        clock which provides time value for the GUI System
211
212        Ticking the GUI means updating it with a certain regularity.
213        The elapsed time since the last call is given in the time value provided by the clock.
214        This time value is then used to provide a fluent animation of the GUI.
215    */
216    void GUIManager::update(const Clock& time)
217    {
218        assert(guiSystem_);
219        guiSystem_->injectTimePulse(time.getDeltaTime());
220    }
221
222    /**
223    @brief
224        Executes Lua code
225    @param str
226        reference to string object holding the Lua code which is to be executed
227
228        This function gives total access to the GUI. You can execute ANY Lua code here.
229    */
230    void GUIManager::executeCode(const std::string& str)
231    {
232        try
233        {
234            this->scriptModule_->executeString(str);
235        }
236        catch (CEGUI::Exception& ex)
237        {
238            COUT(2) << "CEGUI Error: \"" << ex.getMessage() << "\" while executing code \"" << str << "\"" << std::endl;
239        }
240    }
241
242    /**
243    @brief
244        Tells the GUIManager which SceneManager to use
245    @param camera
246        The current camera on which the GUI should be displayed on.
247
248        In fact the GUIManager needs the SceneManager and not the Camera to display the GUI.
249        This means the GUI is not bound to a camera but rather to the SceneManager.
250        Hidding the GUI when needed can therefore not be solved by just NOT setting the current camera.
251    */
252    void GUIManager::setCamera(Ogre::Camera* camera)
253    {
254        this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
255    }
256
257    /**
258    @brief
259        Displays specified GUI on screen
260    @param name
261        The name of the GUI
262
263        The function executes the Lua function with the same name in case the GUIManager is ready.
264        For more details check out loadGUI_2.lua where the function presides.
265    */
266    void GUIManager::showGUI(const std::string& name)
267    {
268        if (state_ != Uninitialised)
269        {
270            //COUT(3) << "Loading GUI " << name << std::endl;
271            try
272            {
273                this->scriptModule_->executeString(std::string("showGUI(\"") + name + "\")");
274            }
275            catch (CEGUI::Exception& ex)
276            {
277                COUT(2) << "Error while executing lua script. Message:\n" << ex.getMessage() << std::endl;
278            }
279            catch (...)
280            {
281                COUT(2) << "Could show a menu due to unknown reasons." << std::endl;
282            }
283        }
284        else
285        {
286            COUT(2) << "Warning: GUI Manager not yet initialised, cannot load a GUI" << std::endl;
287        }
288    }
289
290    /**
291    @brief
292        Function receiving a mouse button pressed event.
293    @param id
294        ID of the mouse button which got pressed
295
296        This function is inherited by MouseHandler and injects the event into CEGUI.
297        It is for CEGUI to process the event.
298    */
299    void GUIManager::mouseButtonPressed(MouseButtonCode::ByEnum id)
300    {
301        try
302        {
303            guiSystem_->injectMouseButtonDown(convertButton(id));
304        }
305        catch (CEGUI::ScriptException& ex)
306        {
307            // We simply ignore the exception and proceed
308            COUT(1) << ex.getMessage() << std::endl;
309        }
310    }
311
312    /**
313    @brief
314        Function receiving a mouse button released event.
315    @param id
316        ID of the mouse button which got released
317
318        This function is inherited by MouseHandler and injects the event into CEGUI.
319        It is for CEGUI to process the event.
320    */
321    void GUIManager::mouseButtonReleased(MouseButtonCode::ByEnum id)
322    {
323        try
324        {
325            guiSystem_->injectMouseButtonUp(convertButton(id));
326        }
327        catch (CEGUI::ScriptException& ex)
328        {
329            // We simply ignore the exception and proceed
330            COUT(1) << ex.getMessage() << std::endl;
331        }
332    }
333
334    /**
335    @brief
336        converts mouse event code to CEGUI event code
337    @param button
338        code of the mouse button as we use it in Orxonox
339    @return
340        code of the mouse button as it is used by CEGUI
341
342        Simple convertion from mouse event code in Orxonox to the one used in CEGUI.
343     */
344    inline CEGUI::MouseButton GUIManager::convertButton(MouseButtonCode::ByEnum button)
345    {
346        switch (button)
347        {
348        case MouseButtonCode::Left:
349            return CEGUI::LeftButton;
350
351        case MouseButtonCode::Right:
352            return CEGUI::RightButton;
353
354        case MouseButtonCode::Middle:
355            return CEGUI::MiddleButton;
356
357        case MouseButtonCode::Button3:
358            return CEGUI::X1Button;
359
360        case MouseButtonCode::Button4:
361            return CEGUI::X2Button;
362
363        default:
364            return CEGUI::NoButton;
365        }
366    }
367}
Note: See TracBrowser for help on using the repository browser.