GUI.h

Go to the documentation of this file.

//    Copyright (C) 2004-2014 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef GUI_H
#define GUI_H

#include "GOgreApp.h"
#include "GUIScreen.h"

#include <RendererModules/Ogre/CEGUIOgreRenderer.h>
#include <RendererModules/Ogre/CEGUIOgreResourceProvider.h>

#include <OgreStringConverter.h>
#include <OgreException.h>

#include <SdkTrays.h>

#include <stack>

#ifndef _WIN32
typedef void (__attribute__((stdcall)) *NodePickedCallback)(const char* name_);
#else
typedef void (__stdcall *NodePickedCallback)(const char* name_);
#endif

namespace OpenSkyNet {
    namespace Graphics {
        class UI;

        class InputListener : public OIS::KeyListener, public OIS::MouseListener {
        public:
            Graphics::UI* _UI;
            CEGUI::Renderer* _gUIRenderer;
            Ogre::SceneNode* _topNode;
            Ogre::SceneNode* _currPickedNode;
            Ogre::Camera* _cam;
            NodePickedCallback _nodePickedCallback;

            Ogre::Vector3 _rayDirection, _rayOrigin;

            InputListener() : _UI(0), _gUIRenderer(0), _topNode(0), 
                _currPickedNode(0), _cam(0), _nodePickedCallback(0) {}

            virtual ~InputListener() {}

            virtual bool keyPressed(const OIS::KeyEvent& arg);
            virtual bool keyReleased(const OIS::KeyEvent& arg);

            virtual void pickNode(Ogre::SceneNode* node_);
            inline void setNodePickedCallback(NodePickedCallback nodePickedCallback_) { _nodePickedCallback = nodePickedCallback_; }

            virtual bool mouseMoved(const OIS::MouseEvent& arg);

            virtual bool mousePressed(const OIS::MouseEvent& arg, OIS::MouseButtonID id);

            virtual bool mouseReleased(const OIS::MouseEvent& arg, OIS::MouseButtonID id);
        };

        class UI : public OgreApp, public Ogre::FrameListener, public Ogre::WindowEventListener, public OgreBites::SdkTrayListener {
            friend class Graphics::InputListener;
        protected:
            CEGUI::OgreRenderer* _gUIRenderer;
            CEGUI::System* _gUISystem;
            std::stack<UIScreen*> _screens;

            bool _useBufferedInputKeys, _useBufferedInputMouse;
            Ogre::Real _moveSpeed, _rotateSpeed;
            float _moveScale, _rotScale;
            bool _statsOn;
            Utils::uint _numScreenShots;

            // To stop toggles flipping too fast
            Ogre::Real _timeUntilNextToggle;

            int _sceneDetailIndex;
            Ogre::Vector3 _translateVector;
            int _aniso;
            Ogre::TextureFilterOptions _filtering;
            float _rotX, _rotY;
            bool _canTranslateCam, _canRotateCam;

            //OIS Input devices
            OIS::InputManager* _inputManager;
            OIS::Mouse*    _mouse;
            OIS::Keyboard* _keyboard;
            InputListener* _inputListener;

            //Manages simple GUI components using the OGRE Overlay system (NOT CEGUI)
            OgreBites::SdkTrayManager* _trayManager;

            volatile bool _quit;
            Ogre::Vector3 _trans;

            Ogre::DisplayString _debugText;
        public:
            UI(InputListener* inputListener_=0);

            virtual bool setup(bool restoreOgreConfig_);
            inline void setTopNodeForMousePicking(Ogre::SceneNode* n_=0) { _inputListener->_topNode = n_; }
            virtual void setupEventHandlers() {}

            inline UIScreen* getTopScreen() const { return (_screens.empty() ? 0 : _screens.top()); }
            virtual void pushScreen(UIScreen* screen_);
            virtual void popScreen(bool doUnload_=true);
            inline void popAndUnloadScreenNextUpdate() { if (!_screens.empty()) _screens.top()->popAndUnloadScreenNextUpdate(); }

            inline void setCanTranslateCam(bool val_) { _canTranslateCam = val_; }
            inline void setCanRotateCam(bool val_) { _canRotateCam = val_; }

            virtual void moveCamera() {
                using namespace Ogre;

                if (_canRotateCam) {
                    _camera->yaw(Degree(_rotX));
                    _camera->pitch(Degree(_rotY));
                }

                if (_canTranslateCam)
                    _camera->moveRelative(_translateVector);
            }

            inline void showDebugOverlay(bool show_) {
                if (show_)
                    _trayManager->showFrameStats(OgreBites::TL_BOTTOMRIGHT);
                else
                    _trayManager->hideFrameStats();
            }

            virtual bool processUnbufferedKeyInput(const Ogre::FrameEvent& evt);
            virtual bool processUnbufferedMouseInput(const Ogre::FrameEvent& evt);

            virtual void windowResized(Ogre::RenderWindow* rw);
            virtual void windowClosed(Ogre::RenderWindow* rw);

            virtual bool frameStarted(const Ogre::FrameEvent& evt);
            virtual bool frameEnded(const Ogre::FrameEvent& evt) {
                _trayManager->frameRenderingQueued(evt);
                return true;
            }

            virtual void switchMouseMode() {
                if (!_useBufferedInputMouse && _timeUntilNextToggle > 0.0f) return;
                _useBufferedInputMouse = !_useBufferedInputMouse;
                if (_useBufferedInputMouse)
                    _mouse->setEventCallback(_inputListener);
                else
                    _mouse->setEventCallback(0);

                if (!_screens.empty())
                    _screens.top()->switchMouseMode();

                _timeUntilNextToggle = 0.25f;
            }

            virtual void switchKeyMode() {
                _useBufferedInputKeys = !_useBufferedInputKeys;
                if (_useBufferedInputKeys)
                    _keyboard->setEventCallback(_inputListener);
                else
                    _keyboard->setEventCallback(0);
            }

            inline InputListener* getInputListener() { return _inputListener; }

            virtual void destroyScene(bool doDestroyPersistentData_);

            inline void quit() { _quit = true; }

            static CEGUI::MouseButton convertOISMouseButtonToCegui(OIS::MouseButtonID buttonID_);
            static bool doesHitAABB(const Ogre::AxisAlignedBox& AABB_, const Ogre::Vector3& origin_, const Ogre::Vector3& direction_);

            virtual ~UI();
        };
    }
}

#endif //GUI_H