Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/gui/GUIManager.cc @ 3003

Last change on this file since 3003 was 2963, checked in by dafrick, 16 years ago

Some Quest stuff, and the rest for the GUIOverlay I failed to commit before.

  • Property svn:eol-style set to native
File size: 12.3 KB
RevLine 
[1638]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
[2896]24 *      Benjamin Knecht
[1638]25 *   Co-authors:
26 *
[2896]27 *
[1638]28 */
29
30/**
31    @file
[1653]32    @brief
33        Implementation of the GUIManager class.
[1638]34*/
35
36#include "OrxonoxStableHeaders.h"
37#include "GUIManager.h"
38
[2896]39#include <boost/filesystem/path.hpp>
[1638]40#include <OgreRenderWindow.h>
41#include <CEGUI.h>
[2710]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
[1764]51#include "util/Exception.h"
[1638]52#include "core/ConsoleCommand.h"
53#include "core/Core.h"
[2896]54#include "core/Clock.h"
[2710]55#include "ToluaBindCore.h"
56#include "ToluaBindOrxonox.h"
[1638]57
[2710]58extern "C" {
59#include <lua.h>
60}
[1638]61
62namespace orxonox
63{
[1646]64    GUIManager* GUIManager::singletonRef_s = 0;
65
[1638]66    GUIManager::GUIManager()
[2896]67        : renderWindow_(0)
[1638]68        , guiRenderer_(0)
69        , resourceProvider_(0)
70        , scriptModule_(0)
71        , guiSystem_(0)
72        , state_(Uninitialised)
73    {
[1646]74        assert(singletonRef_s == 0);
75        singletonRef_s = this;
[1638]76    }
77
[2896]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    */
[1638]84    GUIManager::~GUIManager()
85    {
[1646]86        if (guiSystem_)
87            delete guiSystem_;
88
89        if (scriptModule_)
90        {
91            // destroy our own tolua interfaces
[2662]92                lua_pushnil(luaState_);
93                lua_setglobal(luaState_, "Orxonox");
94                lua_pushnil(luaState_);
95                lua_setglobal(luaState_, "Core");
96            delete scriptModule_;
[1646]97        }
98
99        if (guiRenderer_)
100            delete guiRenderer_;
101
102        singletonRef_s = 0;
[1638]103    }
104
[2896]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    */
[1686]119    bool GUIManager::initialise(Ogre::RenderWindow* renderWindow)
[1638]120    {
121        using namespace CEGUI;
122        if (state_ == Uninitialised)
123        {
[1776]124            COUT(3) << "Initialising CEGUI." << std::endl;
[1638]125
126            try
127            {
[1686]128                // save the render window
129                renderWindow_ = renderWindow;
[1638]130
131                // Note: No SceneManager specified yet
[2896]132                this->guiRenderer_ = new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_OVERLAY, true, 3000);
[1638]133                this->resourceProvider_ = guiRenderer_->createResourceProvider();
134                this->resourceProvider_->setDefaultResourceGroup("GUI");
[1776]135
[1638]136                // setup scripting
137                this->scriptModule_ = new LuaScriptModule();
[1646]138                this->luaState_ = this->scriptModule_->getLuaState();
[1638]139
[2710]140                // Create our own logger to specify the filepath
141                boost::filesystem::path ceguiLogFilepath(Core::getLogPath() / "cegui.log");
142                this->ceguiLogger_ = new DefaultLogger();
[2759]143                this->ceguiLogger_->setLogFilename(ceguiLogFilepath.string());
[2710]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
[1638]148                // create the CEGUI system singleton
149                this->guiSystem_ = new System(this->guiRenderer_, this->resourceProvider_, 0, this->scriptModule_);
[1776]150
[1638]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
[2896]155                // initialise the basic lua code
156                loadLuaCode();
[1638]157            }
158            catch (CEGUI::Exception& ex)
159            {
[1653]160#if CEGUI_VERSION_MAJOR == 0 && CEGUI_VERSION_MINOR < 6
[1645]161                throw GeneralException(ex.getMessage().c_str());
162#else
[1638]163                throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
164                    ex.getFileName().c_str(), ex.getName().c_str());
[1645]165#endif
[1638]166            }
167
168            state_ = Ready;
169        }
[1776]170
[1638]171        return true;
172    }
173
[2896]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()
[2790]186    {
[2896]187        try
[2790]188        {
[2896]189            // set datapath for GUI data
190            lua_pushfstring(this->scriptModule_->getLuaState(), Core::getMediaPathString().c_str());
191            lua_setglobal(this->scriptModule_->getLuaState(), "datapath");
[2957]192            // call main Lua script
193            this->scriptModule_->executeScriptFile("loadGUI_3.lua", "GUI");
[2896]194        }
195        catch (CEGUI::Exception& ex)
196        {
[2790]197#if CEGUI_VERSION_MINOR < 6
[2896]198            throw GeneralException(ex.getMessage().c_str());
[2790]199#else
[2896]200            throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
201                ex.getFileName().c_str(), ex.getName().c_str());
[2790]202#endif
203        }
204    }
205
[2896]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)
[1638]217    {
[2896]218        assert(guiSystem_);
219        guiSystem_->injectTimePulse(time.getDeltaTime());
220    }
[1638]221
[2896]222    /**
223    @brief
224        Executes Lua code
225    @param str
226        reference to string object holding the Lua code which is to be executed
[1638]227
[2896]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    {
[1638]232        try
233        {
[2896]234            this->scriptModule_->executeString(str);
[1638]235        }
236        catch (CEGUI::Exception& ex)
237        {
[2896]238            COUT(2) << "CEGUI Error: \"" << ex.getMessage() << "\" while executing code \"" << str << "\"" << std::endl;
[1638]239        }
240    }
241
[2896]242    /**
243    @brief
[2963]244        Registers a GUIOverlay with the GUIManager so that the GUIOverlay can be accessed by it's name through the GUIManager.
245    @param name
246        The name of the GUI.
247    @param overlay
248        A pointer to the GUIOverlay of the GUI.
249    @return
250        Returns false if the Overlay was already present.
251    */
252    bool GUIManager::registerOverlay(std::string name, GUIOverlay* overlay)
253    {
254        return (this->guiOverlays_.insert(std::pair<std::string, GUIOverlay*>(name, overlay))).second;
255    }
256
257    /**
258    @brief
259        Get the GUIOverlay of the GUI with the given name.
260    @param name
261        The name of the GUI.
262    @return
263        Returns a pointer to the GUIOverlay.
264    */
265    GUIOverlay* GUIManager::getOverlay(std::string name)
266    {
267        return (this->guiOverlays_.find(name))->second;
268    }
269
270    /**
271    @brief
[2896]272        Tells the GUIManager which SceneManager to use
273    @param camera
274        The current camera on which the GUI should be displayed on.
275
276        In fact the GUIManager needs the SceneManager and not the Camera to display the GUI.
277        This means the GUI is not bound to a camera but rather to the SceneManager.
278        Hidding the GUI when needed can therefore not be solved by just NOT setting the current camera.
279    */
280    void GUIManager::setCamera(Ogre::Camera* camera)
[1638]281    {
[2927]282        if (camera == NULL)
283            this->guiRenderer_->setTargetSceneManager(0);
284        else
285            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
[2896]286    }
287
288    /**
289    @brief
290        Displays specified GUI on screen
291    @param name
292        The name of the GUI
293
294        The function executes the Lua function with the same name in case the GUIManager is ready.
295        For more details check out loadGUI_2.lua where the function presides.
296    */
297    void GUIManager::showGUI(const std::string& name)
298    {
[1638]299        if (state_ != Uninitialised)
300        {
[2896]301            //COUT(3) << "Loading GUI " << name << std::endl;
[1638]302            try
303            {
[2896]304                this->scriptModule_->executeString(std::string("showGUI(\"") + name + "\")");
[1638]305            }
306            catch (CEGUI::Exception& ex)
307            {
308                COUT(2) << "Error while executing lua script. Message:\n" << ex.getMessage() << std::endl;
309            }
310            catch (...)
311            {
312                COUT(2) << "Could show a menu due to unknown reasons." << std::endl;
313            }
314        }
315        else
316        {
317            COUT(2) << "Warning: GUI Manager not yet initialised, cannot load a GUI" << std::endl;
318        }
319    }
320
[2896]321    /**
322    @brief
323        Function receiving a mouse button pressed event.
324    @param id
325        ID of the mouse button which got pressed
[1638]326
[2896]327        This function is inherited by MouseHandler and injects the event into CEGUI.
328        It is for CEGUI to process the event.
329    */
[1887]330    void GUIManager::mouseButtonPressed(MouseButtonCode::ByEnum id)
[1638]331    {
332        try
333        {
334            guiSystem_->injectMouseButtonDown(convertButton(id));
335        }
336        catch (CEGUI::ScriptException& ex)
337        {
338            // We simply ignore the exception and proceed
339            COUT(1) << ex.getMessage() << std::endl;
340        }
341    }
342
[2896]343    /**
344    @brief
345        Function receiving a mouse button released event.
346    @param id
347        ID of the mouse button which got released
348
349        This function is inherited by MouseHandler and injects the event into CEGUI.
350        It is for CEGUI to process the event.
351    */
[1887]352    void GUIManager::mouseButtonReleased(MouseButtonCode::ByEnum id)
[1638]353    {
354        try
355        {
356            guiSystem_->injectMouseButtonUp(convertButton(id));
357        }
358        catch (CEGUI::ScriptException& ex)
359        {
360            // We simply ignore the exception and proceed
361            COUT(1) << ex.getMessage() << std::endl;
362        }
363    }
364
[2896]365    /**
366    @brief
367        converts mouse event code to CEGUI event code
368    @param button
369        code of the mouse button as we use it in Orxonox
370    @return
371        code of the mouse button as it is used by CEGUI
[1638]372
[2896]373        Simple convertion from mouse event code in Orxonox to the one used in CEGUI.
374     */
[1887]375    inline CEGUI::MouseButton GUIManager::convertButton(MouseButtonCode::ByEnum button)
[1638]376    {
377        switch (button)
378        {
[1887]379        case MouseButtonCode::Left:
[1638]380            return CEGUI::LeftButton;
381
[1887]382        case MouseButtonCode::Right:
[1638]383            return CEGUI::RightButton;
384
[1887]385        case MouseButtonCode::Middle:
[1638]386            return CEGUI::MiddleButton;
387
[1887]388        case MouseButtonCode::Button3:
[1638]389            return CEGUI::X1Button;
390
[1887]391        case MouseButtonCode::Button4:
[1638]392            return CEGUI::X2Button;
393
394        default:
395            return CEGUI::NoButton;
396        }
397    }
398}
Note: See TracBrowser for help on using the repository browser.