engine.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2010-2015 Marianne Gagnon
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 
#ifndef HEADER_ENGINE_HPP
#define HEADER_ENGINE_HPP
 
namespace irr
{
    class IrrlichtDevice;
    namespace gui   { class IGUIEnvironment; class ScalableFont; }
    namespace video { class IVideoDriver; class ITexture;        }
}
 
#include <functional>
#include <string>
 
#include "utils/constants.hpp"
#include "utils/ptr_vector.hpp"
 
#include "irrString.h"
 
namespace GUIEngine
{
    class Screen;
    class Widget;
    class Skin;
    class AbstractStateManager;
 
    Widget* getFocusForPlayer(const unsigned int playerID);
 
    void focusNothingForPlayer(const unsigned int playerID);
 
    bool isFocusedForPlayer(const Widget*w, const unsigned int playerID);
 
    namespace Private
    {
        extern irr::gui::IGUIEnvironment* g_env;
        extern Skin* g_skin;
        extern irr::gui::ScalableFont* g_small_font;
        extern irr::gui::ScalableFont* g_font;
        extern irr::gui::ScalableFont* g_outline_font;
        extern irr::gui::ScalableFont* g_large_font;
        extern irr::gui::ScalableFont* g_title_font;
        extern irr::gui::ScalableFont* g_small_title_font;
        extern irr::gui::ScalableFont* g_tiny_title_font;
        extern irr::gui::ScalableFont* g_digit_font;
 
        extern irr::IrrlichtDevice* g_device;
        extern irr::video::IVideoDriver* g_driver;
        extern Screen* g_current_screen;
        extern AbstractStateManager* g_state_manager;
        extern Widget* g_focus_for_player[MAX_PLAYER_COUNT];
    }
 
    extern PtrVector<Widget, REF> needsUpdate;
 
    void init(irr::IrrlichtDevice* device, irr::video::IVideoDriver* driver,
              AbstractStateManager* state_manager, bool loading = true);
 
    void cleanUp();
 
    void deallocate();
 
    void resetGlobalVariables();
 
    inline irr::IrrlichtDevice*       getDevice()        { return Private::g_device;         }
 
    inline irr::gui::IGUIEnvironment* getGUIEnv()        { return Private::g_env;            }
 
    inline irr::video::IVideoDriver*  getDriver()        { return Private::g_driver;         }
 
    inline irr::gui::ScalableFont*    getSmallFont()     { return Private::g_small_font;     }
 
    inline irr::gui::ScalableFont*    getFont()          { return Private::g_font;           }
 
    inline irr::gui::ScalableFont*    getOutlineFont()   { return Private::g_outline_font;   }
 
    inline irr::gui::ScalableFont*    getLargeFont()     { return Private::g_large_font;     }
 
    inline irr::gui::ScalableFont*    getHighresDigitFont() { return Private::g_digit_font;  }
 
    inline irr::gui::ScalableFont*    getTitleFont()     { return Private::g_title_font;     }
    
    inline irr::gui::ScalableFont*    getSmallTitleFont() { return Private::g_small_title_font; }
    
    inline irr::gui::ScalableFont*    getTinyTitleFont() { return Private::g_tiny_title_font; }
 
    inline Screen*                    getCurrentScreen() { return Private::g_current_screen; }
 
    inline AbstractStateManager*      getStateManager()  { return Private::g_state_manager;  }
 
    void clearScreenCache();
 
    inline Skin*                      getSkin()          { return Private::g_skin;           }
 
    inline void                       setSkin(Skin* skin) { Private::g_skin = skin;          }
    Screen*                           getScreenNamed(const char* name);
 
    int   getTitleFontHeight();
 
    int   getFontHeight();
 
    int   getSmallFontHeight();
 
    float getLatestDt();
 
    void showMessage(const irr::core::stringw& message, const float time=5.0f);
 
    void  addScreenToList(Screen* screen);
    void  removeScreen(Screen* screen);
 
    void switchToScreen(Screen* screen);
 
    void clear();
 
    void update(float dt);
 
    void cleanForGame();
 
    void reshowCurrentScreen();
 
    void render(float dt, bool is_loading = false);
 
    void clearLoadingTips();
 
    void renderLoading(bool clearIcons = true, bool launching = false, bool update_tips = true);
 
    void flushRenderLoading(bool launching);
 
    void reserveLoadingIcons(int count);
 
    void addLoadingIcon(irr::video::ITexture* icon);
 
    Widget* getWidget(const char* name);
 
    Widget* getWidget(const int id);
 
    void reloadSkin();
 
    void reloadForNewSize();
 
    void addGUIFunctionBeforeRendering(std::function<void()> func);
 
#ifdef SERVER_ONLY
    inline void disableGraphics() {}
    constexpr bool isNoGraphics() { return true; }
#else
    void disableGraphics();
    bool isNoGraphics();
#endif
}
 
#endif