Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/toonshader/src/orxonox/gui/GUIManager.cc @ 8474

Last change on this file since 8474 was 2927, checked in by rgrieder, 16 years ago

Fixed three memory leaks and a bug.
@beni: Is deleting the "startGame" console command a problem or did we just forget to remove the comment characters?

  • Property svn:eol-style set to native
File size: 11.5 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        if (camera == NULL)
255            this->guiRenderer_->setTargetSceneManager(0);
256        else
257            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
258    }
259
260    /**
261    @brief
262        Displays specified GUI on screen
263    @param name
264        The name of the GUI
265
266        The function executes the Lua function with the same name in case the GUIManager is ready.
267        For more details check out loadGUI_2.lua where the function presides.
268    */
269    void GUIManager::showGUI(const std::string& name)
270    {
271        if (state_ != Uninitialised)
272        {
273            //COUT(3) << "Loading GUI " << name << std::endl;
274            try
275            {
276                this->scriptModule_->executeString(std::string("showGUI(\"") + name + "\")");
277            }
278            catch (CEGUI::Exception& ex)
279            {
280                COUT(2) << "Error while executing lua script. Message:\n" << ex.getMessage() << std::endl;
281            }
282            catch (...)
283            {
284                COUT(2) << "Could show a menu due to unknown reasons." << std::endl;
285            }
286        }
287        else
288        {
289            COUT(2) << "Warning: GUI Manager not yet initialised, cannot load a GUI" << std::endl;
290        }
291    }
292
293    /**
294    @brief
295        Function receiving a mouse button pressed event.
296    @param id
297        ID of the mouse button which got pressed
298
299        This function is inherited by MouseHandler and injects the event into CEGUI.
300        It is for CEGUI to process the event.
301    */
302    void GUIManager::mouseButtonPressed(MouseButtonCode::ByEnum id)
303    {
304        try
305        {
306            guiSystem_->injectMouseButtonDown(convertButton(id));
307        }
308        catch (CEGUI::ScriptException& ex)
309        {
310            // We simply ignore the exception and proceed
311            COUT(1) << ex.getMessage() << std::endl;
312        }
313    }
314
315    /**
316    @brief
317        Function receiving a mouse button released event.
318    @param id
319        ID of the mouse button which got released
320
321        This function is inherited by MouseHandler and injects the event into CEGUI.
322        It is for CEGUI to process the event.
323    */
324    void GUIManager::mouseButtonReleased(MouseButtonCode::ByEnum id)
325    {
326        try
327        {
328            guiSystem_->injectMouseButtonUp(convertButton(id));
329        }
330        catch (CEGUI::ScriptException& ex)
331        {
332            // We simply ignore the exception and proceed
333            COUT(1) << ex.getMessage() << std::endl;
334        }
335    }
336
337    /**
338    @brief
339        converts mouse event code to CEGUI event code
340    @param button
341        code of the mouse button as we use it in Orxonox
342    @return
343        code of the mouse button as it is used by CEGUI
344
345        Simple convertion from mouse event code in Orxonox to the one used in CEGUI.
346     */
347    inline CEGUI::MouseButton GUIManager::convertButton(MouseButtonCode::ByEnum button)
348    {
349        switch (button)
350        {
351        case MouseButtonCode::Left:
352            return CEGUI::LeftButton;
353
354        case MouseButtonCode::Right:
355            return CEGUI::RightButton;
356
357        case MouseButtonCode::Middle:
358            return CEGUI::MiddleButton;
359
360        case MouseButtonCode::Button3:
361            return CEGUI::X1Button;
362
363        case MouseButtonCode::Button4:
364            return CEGUI::X2Button;
365
366        default:
367            return CEGUI::NoButton;
368        }
369    }
370}
Note: See TracBrowser for help on using the repository browser.