enginesettings.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2013 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE 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.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_ENGINESETTINGS_H
#define FIFE_ENGINESETTINGS_H

// Standard C++ library includes
#include <vector>

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "util/base/exception.h"
#include "video/renderbackend.h"

namespace FIFE {
    class NotSupported;

    class EngineSettings {
    public:
        EngineSettings();

        ~EngineSettings();

        void setBitsPerPixel(uint8_t bitsperpixel);

        uint8_t getBitsPerPixel() const {
            return m_bitsperpixel;
        }

        std::vector<uint8_t> getPossibleBitsPerPixel() const;

        void setFullScreen(bool fullscreen) {
            m_fullscreen = fullscreen;
        }

        bool isFullScreen() const {
            return m_fullscreen;
        }

        void setInitialVolume(float volume);

        float getInitialVolume() const {
            return m_initialvolume;
        }

        float getMaxVolume() const;

        void setRenderBackend(const std::string& renderbackend);

        const std::string& getRenderBackend() const {
            return m_renderbackend;
        }

        std::string getRenderBackend() {
            return m_renderbackend;
        }

        std::vector<std::string> getPossibleRenderBackends();

        void setSDLRemoveFakeAlpha(bool sdlremovefakealpha);

        bool isSDLRemoveFakeAlpha() const {
            return m_sdlremovefakealpha;
        }

        void setGLCompressImages(bool oglcompressimages);

        bool isGLCompressImages() const {
            return m_oglcompressimages;
        }

        void setGLUseFramebuffer(bool ogluseframebuffer);

        bool isGLUseFramebuffer() const {
            return m_ogluseframebuffer;
        }

        void setGLUseNPOT(bool oglusenpot);

        bool isGLUseNPOT() const {
            return m_oglusenpot;
        }

        void setGLTextureFiltering(TextureFiltering filter);

        TextureFiltering getGLTextureFiltering() const;

        void setGLUseMipmapping(bool mipmapping);

        bool isGLUseMipmapping() const;

        void setGLUseMonochrome(bool monochrome);
        
        bool isGLUseMonochrome() const;

        void setGLUseDepthBuffer(bool buffer);

        bool isGLUseDepthBuffer() const;

        void setGLAlphaTestValue(float alpha);

        float getGLAlphaTestValue() const;

        void setScreenWidth(uint16_t screenwidth);

        uint16_t getScreenWidth() const {
            return m_screenwidth;
        }

        void setScreenHeight(uint16_t screenheight);

        uint16_t getScreenHeight() const {
            return m_screenheight;
        }

        void setDefaultFontPath(const std::string& defaultfontpath);

        const std::string& getDefaultFontPath() const {
            return m_defaultfontpath;
        }

        std::string getDefaultFontPath() {
            return m_defaultfontpath;
        }

        void setDefaultFontSize(uint16_t defaultfontsize);

        uint16_t getDefaultFontSize() const {
            return m_defaultfontsize;
        }

        void setDefaultFontGlyphs(const std::string& defaultfontglyphs);

        const std::string& getDefaultFontGlyphs() const {
            return m_defaultfontglyphs;
        }

        std::string getDefaultFontGlyphs() {
            return m_defaultfontglyphs;
        }

        void setWindowTitle(const std::string& title);

        const std::string& getWindowTitle() const {
            return m_windowtitle;
        }

        std::string getWindowTitle() {
            return m_windowtitle;
        }

        void setWindowIcon(const std::string& icon);

        const std::string& getWindowIcon() const {
            return m_windowicon;
        }

        std::string getWindowIcon() {
            return m_windowicon;
        }

        void setColorKeyEnabled(bool colorkeyenable);

        bool isColorKeyEnabled() const;

        void setColorKey(uint8_t r, uint8_t g, uint8_t b);

        const SDL_Color& getColorKey() const;

        void setVideoDriver(const std::string& driver);

        const std::string& getVideoDriver() const;

        void setLightingModel(uint32_t lighting);

        uint32_t getLightingModel() const {
            return m_lighting;
        }

        void setFrameLimitEnabled(bool limited);

        bool isFrameLimitEnabled() const;

        void setFrameLimit(uint16_t framelimit);

        uint16_t getFrameLimit() const;

        void setMouseSensitivity(float sens);

        float getMouseSensitivity() const;

        void setMouseAccelerationEnabled(bool acceleration);

        bool isMouseAccelerationEnabled() const;

    private:
        uint8_t m_bitsperpixel;
        bool m_fullscreen;
        float m_initialvolume;
        std::string m_renderbackend;
        bool m_sdlremovefakealpha;
        bool m_oglcompressimages;
        bool m_ogluseframebuffer;
        bool m_oglusenpot;
        bool m_oglMipmapping;
        bool m_oglMonochrome;
        TextureFiltering m_oglTextureFilter;
        bool m_oglDepthBuffer;
        float m_alphaTestValue;
        uint16_t m_screenwidth;
        uint16_t m_screenheight;
        std::string m_windowtitle;
        std::string m_windowicon;


        std::string m_defaultfontpath;
        uint16_t m_defaultfontsize;
        std::string m_defaultfontglyphs;
        bool m_iscolorkeyenabled;
        SDL_Color m_colorkey;
        std::string m_videodriver;
        uint32_t m_lighting;
        bool m_isframelimit;
        uint16_t m_framelimit;
        float m_mousesensitivity;
        bool m_mouseacceleration;
    };

}//FIFE

#endif