Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Apr 8, 2009, 12:58:47 AM (16 years ago)
Author:
dafrick
Message:

Reverted to revision 2906 (because I'm too stupid to merge correctly, 2nd try will follow shortly. ;))

Location:
code/branches/questsystem5
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • code/branches/questsystem5

  • code/branches/questsystem5/src/orxonox/gui/GUIManager.cc

    r2907 r2908  
    2222 *   Author:
    2323 *      Reto Grieder
    24  *      Benjamin Knecht
    2524 *   Co-authors:
    26  *
     25 *      ...
    2726 *
    2827 */
    … …  
    3736#include "GUIManager.h"
    3837
    39 #include <boost/filesystem/path.hpp>
     38#include <boost/filesystem.hpp>
    4039#include <OgreRenderWindow.h>
     40#include <OgreRoot.h>
    4141#include <CEGUI.h>
    4242#include <CEGUIDefaultLogger.h>
    … …  
    5050
    5151#include "util/Exception.h"
     52#include "core/input/InputManager.h"
     53#include "core/input/SimpleInputState.h"
    5254#include "core/ConsoleCommand.h"
    5355#include "core/Core.h"
    54 #include "core/Clock.h"
    5556#include "ToluaBindCore.h"
    5657#include "ToluaBindOrxonox.h"
    … …  
    6263namespace orxonox
    6364{
     65    SetConsoleCommandShortcut(GUIManager, showGUI_s).keybindMode(KeybindMode::OnPress);
     66
    6467    GUIManager* GUIManager::singletonRef_s = 0;
    6568
    6669    GUIManager::GUIManager()
    67         : renderWindow_(0)
     70        //: emptySceneManager_(0)
     71        : backgroundSceneManager_(0)
     72        //, emptyCamera_(0)
     73        , backgroundCamera_(0)
     74        //, viewport_(0)
     75        , renderWindow_(0)
    6876        , guiRenderer_(0)
    6977        , resourceProvider_(0)
    … …  
    7684    }
    7785
    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     */
    8486    GUIManager::~GUIManager()
    8587    {
     88        if (backgroundCamera_)
     89            backgroundSceneManager_->destroyCamera(backgroundCamera_);
     90
     91        if (backgroundSceneManager_)
     92        {
     93            // We have to make sure the SceneManager is not anymore referenced.
     94            // For the case that the target SceneManager was yet another one, it
     95            // wouldn't matter anyway since this is the destructor.
     96            guiRenderer_->setTargetSceneManager(0);
     97            Ogre::Root::getSingleton().destroySceneManager(backgroundSceneManager_);
     98        }
     99
     100        InputManager::getInstance().requestDestroyState("gui");
     101
    86102        if (guiSystem_)
    87103            delete guiSystem_;
    … …  
    94110                lua_pushnil(luaState_);
    95111                lua_setglobal(luaState_, "Core");
     112            // TODO: deleting the script module fails an assertion.
     113            // However there is not much we can do about it since it occurs too when
     114            // we don't open Core or Orxonox. Might be a CEGUI issue.
     115            // The memory leak is not a problem anyway..
    96116            delete scriptModule_;
    97117        }
    … …  
    103123    }
    104124
    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     */
    119125    bool GUIManager::initialise(Ogre::RenderWindow* renderWindow)
    120126    {
    … …  
    129135                renderWindow_ = renderWindow;
    130136
     137                // Full screen viewport with Z order = 0 (top most). Don't yet feed a camera (so nothing gets rendered)
     138                //this->viewport_ = renderWindow_->addViewport(0, 3);
     139                //this->viewport_->setOverlaysEnabled(false);
     140                //this->viewport_->setShadowsEnabled(false);
     141                //this->viewport_->setSkiesEnabled(false);
     142                //this->viewport_->setClearEveryFrame(false);
     143
    131144                // Note: No SceneManager specified yet
    132                 this->guiRenderer_ = new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_OVERLAY, true, 3000);
     145                this->guiRenderer_ = new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_MAIN, true, 3000);
    133146                this->resourceProvider_ = guiRenderer_->createResourceProvider();
    134147                this->resourceProvider_->setDefaultResourceGroup("GUI");
    … …  
    153166                tolua_Orxonox_open(this->scriptModule_->getLuaState());
    154167
    155                 // initialise the basic lua code
    156                 loadLuaCode();
     168                // register us as input handler
     169                SimpleInputState* state = InputManager::getInstance().createInputState<SimpleInputState>("gui", 30);
     170                state->setHandler(this);
     171                state->setJoyStickHandler(&InputManager::EMPTY_HANDLER);
     172
     173                // load the background scene
     174                loadScenes();
     175                //CEGUI::KeyEventArgs e;
     176                //e.codepoint
    157177            }
    158178            catch (CEGUI::Exception& ex)
    … …  
    172192    }
    173193
    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     {
     194    void GUIManager::loadScenes()
     195    {
     196        // first of all, we need to have our own SceneManager for the GUI. The reason
     197        // is that we might have multiple viewports when in play mode (e.g. the view of
     198        // a camera fixed at the back of the ship). That forces us to create our own
     199        // full screen viewport that is on top of all the others, but doesn't clear the
     200        // port before rendering, so everything from the GUI gets on top eventually.
     201        // But in order to realise that, we also need a SceneManager with an empty scene,
     202        // because the SceneManager is responsible for the render queue.
     203        //this->emptySceneManager_ = Ogre::Root::getSingleton()
     204        //    .createSceneManager(Ogre::ST_GENERIC, "GUI/EmptySceneManager");
     205
     206        // we also need a camera or we won't see anything at all.
     207        // The camera settings don't matter at all for an empty scene since the GUI
     208        // gets rendered on top of the screen rather than into the scene.
     209        //this->emptyCamera_ = this->emptySceneManager_->createCamera("GUI/EmptyCamera");
     210
     211        // Create another SceneManager that enables to display some 3D
     212        // scene in the background of the main menu.
     213        this->backgroundSceneManager_ = Ogre::Root::getSingleton()
     214            .createSceneManager(Ogre::ST_GENERIC, "GUI/BackgroundSceneManager");
     215        this->backgroundCamera_ = backgroundSceneManager_->createCamera("GUI/BackgroundCamera");
     216
     217        // TODO: create something 3D
    187218        try
    188219        {
    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");
     220            this->scriptModule_->executeScriptFile("loadGUI.lua", "GUI");
    194221        }
    195222        catch (CEGUI::Exception& ex)
    … …  
    204231    }
    205232
    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)
     233    void GUIManager::showGUI(const std::string& name, Ogre::SceneManager* sceneManager)// bool showBackground)
    267234    {
    268235        if (state_ != Uninitialised)
    269236        {
    270             //COUT(3) << "Loading GUI " << name << std::endl;
     237            if (state_ == OnDisplay)
     238                hideGUI();
     239
     240            COUT(3) << "Loading GUI " << name << std::endl;
    271241            try
    272242            {
    273                 this->scriptModule_->executeString(std::string("showGUI(\"") + name + "\")");
     243                if (!sceneManager)
     244                {
     245                    // currently, only an image is loaded. We could do 3D, see loadBackground.
     246                    //this->viewport_->setClearEveryFrame(true);
     247                    this->guiRenderer_->setTargetSceneManager(this->backgroundSceneManager_);
     248                    //this->viewport_->setCamera(this->backgroundCamera_);
     249
     250                    lua_pushboolean(this->scriptModule_->getLuaState(), true);
     251                    lua_setglobal(this->scriptModule_->getLuaState(), "showBackground");
     252                }
     253                else
     254                {
     255                    //this->viewport_->setClearEveryFrame(false);
     256                    this->guiRenderer_->setTargetSceneManager(sceneManager);
     257                    //this->viewport_->setCamera(this->emptyCamera_);
     258
     259                    lua_pushboolean(this->scriptModule_->getLuaState(), false);
     260                    lua_setglobal(this->scriptModule_->getLuaState(), "showBackground");
     261                }
     262
     263                this->scriptModule_->executeScriptGlobal("showMainMenu");
     264
     265                InputManager::getInstance().requestEnterState("gui");
     266
     267                this->state_ = OnDisplay;
    274268            }
    275269            catch (CEGUI::Exception& ex)
    … …  
    288282    }
    289283
    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     */
     284    void GUIManager::hideGUI()
     285    {
     286        if (this->state_ != OnDisplay)
     287            return;
     288        //this->viewport_->setCamera(0);
     289        this->guiRenderer_->setTargetSceneManager(0);
     290        this->state_ = Ready;
     291        InputManager::getInstance().requestLeaveState("gui");
     292    }
     293
    299294    void GUIManager::mouseButtonPressed(MouseButtonCode::ByEnum id)
    300295    {
    … …  
    310305    }
    311306
    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     */
    321307    void GUIManager::mouseButtonReleased(MouseButtonCode::ByEnum id)
    322308    {
    … …  
    332318    }
    333319
    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      */
     320
    344321    inline CEGUI::MouseButton GUIManager::convertButton(MouseButtonCode::ByEnum button)
    345322    {

  • code/branches/questsystem5/src/orxonox/gui/GUIManager.h

    r2907 r2908  
    2323 *      Reto Grieder
    2424 *   Co-authors:
    25  *      Benjamin Knecht
     25 *      ...
    2626 *
    2727 */
    … …  
    4949{
    5050    /**
    51     @class GUIManager
    5251    @brief
    53         Provides a simple interface to CEGUI with tolua methods and console commands. It also acts as a key and mouse handler.
    54 
    55         The GUIManager is a singleton and can be called anywhere when access on the GUI is needed.
    56         Creation of the GUIManager is therefore not possible and the cunstructor is private.
    57 
    58         Since the GUI needs user input, the GUIManager implements the functions needed to act as a key and/or mouse handler.
    59         Those input events are then injected into CEGUI in Lua.
     52        Provides a simple interface to CEGUI with tolua methods and console commands
    6053    */
    6154    class _OrxonoxExport GUIManager
    … …  
    6659// tolua_end
    6760    public:
    68         /**
    69         @enum State
    70             The current state of the GUIManager. There should maybe be more (or we can omit this totally).
    71         */
    7261        enum State
    7362        {
    74             Uninitialised,  //!< Initial state of the GUIManager
    75             Ready,          //!< State after initialisation if ready
    76             OnDisplay       //!< State if GUI is displayed
     63            Uninitialised,
     64            Ready,
     65            OnDisplay
    7766        };
    7867
    … …  
    8170
    8271        bool initialise(Ogre::RenderWindow* renderWindow);
     72        void tick(float dt)
     73        {
     74            assert(guiSystem_);
     75            guiSystem_->injectTimePulse(dt);
     76        }
     77        void showGUI(const std::string& name, Ogre::SceneManager* sceneManager);// bool showBackground); // tolua_export
     78        void hideGUI(); // tolua_export
    8379
    84         void update(const Clock& time);
     80        Ogre::Camera* getCamera() { return this->backgroundCamera_; }
    8581
    86         void showGUI(const std::string& name);
    87         void executeCode(const std::string& str);
    88 
    89         void setCamera(Ogre::Camera* camera);
     82        static void showGUI_s(const std::string& name, Ogre::SceneManager* sceneManager)//bool showBackground)
     83        {
     84            getInstance().showGUI(name, sceneManager);
     85        }
    9086
    9187        static GUIManager& getInstance()    { assert(singletonRef_s); return *singletonRef_s; } // tolua_export
    … …  
    9389
    9490    private:
    95         GUIManager(const GUIManager& instance);                 //!< private constructor (this is a singleton class)
     91        GUIManager(const GUIManager& instance);
    9692
    97         void loadLuaCode();
     93        void keyPressed (const KeyEvent& evt)
     94        { guiSystem_->injectKeyDown(evt.key); guiSystem_->injectChar(evt.text); }
     95        void keyReleased(const KeyEvent& evt)
     96        { guiSystem_->injectKeyUp(evt.key); }
     97        void keyHeld    (const KeyEvent& evt)
     98        { }
    9899
    99         // keyHandler functions
    100         void keyPressed (const KeyEvent& evt)
    101             { guiSystem_->injectKeyDown(evt.key); guiSystem_->injectChar(evt.text); }
    102         void keyReleased(const KeyEvent& evt)
    103             { guiSystem_->injectKeyUp(evt.key); }
    104         void keyHeld    (const KeyEvent& evt) { }
    105 
    106         // mouseHandler functions
    107100        void mouseButtonPressed (MouseButtonCode::ByEnum id);
    108101        void mouseButtonReleased(MouseButtonCode::ByEnum id);
    109         void mouseButtonHeld    (MouseButtonCode::ByEnum id) { }
     102        void mouseButtonHeld    (MouseButtonCode::ByEnum id)
     103        { }
    110104        void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
    111             { guiSystem_->injectMouseMove(rel.x, rel.y); }
     105        { guiSystem_->injectMouseMove(rel.x, rel.y); }
    112106        void mouseScrolled      (int abs, int rel)
    113             { guiSystem_->injectMouseWheelChange(rel);}
     107        { guiSystem_->injectMouseWheelChange(rel);}
    114108
    115         void updateInput(float dt)  { }
    116         void updateKey  (float dt)  { }
    117         void updateMouse(float dt)  { }
     109        void tickInput(float dt) { }
     110        void tickKey(float dt) { }
     111        void tickMouse(float dt) { }
     112
     113        void loadScenes();
     114
     115        //Ogre::SceneManager*       emptySceneManager_;
     116        Ogre::SceneManager*       backgroundSceneManager_;
     117        //Ogre::Camera*             emptyCamera_;
     118        Ogre::Camera*             backgroundCamera_;
     119        //Ogre::Viewport*           viewport_;
     120        Ogre::RenderWindow*       renderWindow_;
     121        CEGUI::OgreCEGUIRenderer* guiRenderer_;
     122        CEGUI::ResourceProvider*  resourceProvider_;
     123        CEGUI::LuaScriptModule*   scriptModule_;
     124        CEGUI::DefaultLogger*     ceguiLogger_;
     125        CEGUI::System*            guiSystem_;
     126        CEGUI::Imageset*          backgroundImage_;
     127        lua_State*                luaState_;
     128
     129        State state_;
    118130
    119131        static CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button);
    120132
    121         Ogre::RenderWindow*         renderWindow_;      //!< Ogre's render window to give CEGUI access to it
    122         CEGUI::OgreCEGUIRenderer*   guiRenderer_;       //!< CEGUI's interface to the Ogre Engine
    123         CEGUI::ResourceProvider*    resourceProvider_;  //!< CEGUI's resource provider
    124         CEGUI::LuaScriptModule*     scriptModule_;      //!< CEGUI's script module to use Lua
    125         CEGUI::DefaultLogger*       ceguiLogger_;       //!< CEGUI's logger to be able to log CEGUI errors in our log
    126         CEGUI::System*              guiSystem_;         //!< CEGUI's main system
    127         lua_State*                  luaState_;          //!< Lua state, access point to the Lua engine
    128 
    129         State                       state_;             //!< reflects state of the GUIManager
    130 
    131         static GUIManager*          singletonRef_s;     //!< Singleton reference to GUIManager
     133        static GUIManager*        singletonRef_s;
    132134    }; // tolua_export
    133135} // tolua_export
Note: See TracChangeset for help on using the changeset viewer.