RenderSettings.hh

Go to the documentation of this file.

#ifndef RENDERSETTINGS_HH
#define RENDERSETTINGS_HH
 
#include "BooleanSetting.hh"
#include "EnumSetting.hh"
#include "FloatSetting.hh"
#include "IntegerSetting.hh"
#include "StringSetting.hh"
#include "Observer.hh"
#include "gl_mat.hh"
#include "narrow.hh"
 
namespace openmsx {
 
class CommandController;
class Interpreter;
 
class RenderSettings final : private Observer<Setting>
{
public:
        enum class RendererID { UNINITIALIZED, DUMMY, SDLGL_PP };
        using RendererSetting = EnumSetting<RendererID>;
 
        enum class Accuracy { SCREEN, LINE, PIXEL };
 
        enum class ScaleAlgorithm {
                SIMPLE, SCALE, HQ, RGBTRIPLET, TV,
                NO
        };
 
        enum class DisplayDeform {
                NORMAL, _3D
        };
 
        explicit RenderSettings(CommandController& commandController);
        ~RenderSettings();
 
        [[nodiscard]] EnumSetting<Accuracy>& getAccuracySetting() { return accuracySetting; }
        [[nodiscard]] Accuracy getAccuracy() const { return accuracySetting.getEnum(); }
 
        [[nodiscard]] BooleanSetting& getDeinterlaceSetting() { return deinterlaceSetting; }
        [[nodiscard]] bool getDeinterlace() const { return deinterlaceSetting.getBoolean(); }
 
        [[nodiscard]] BooleanSetting& getDeflickerSetting() { return deflickerSetting; }
        [[nodiscard]] bool getDeflicker() const { return deflickerSetting.getBoolean(); }
 
        [[nodiscard]] IntegerSetting& getMaxFrameSkipSetting() { return maxFrameSkipSetting; }
        [[nodiscard]] int getMaxFrameSkip() const { return maxFrameSkipSetting.getInt(); }
 
        [[nodiscard]] IntegerSetting& getMinFrameSkipSetting() { return minFrameSkipSetting; }
        [[nodiscard]] int getMinFrameSkip() const { return minFrameSkipSetting.getInt(); }
 
        [[nodiscard]] BooleanSetting& getFullScreenSetting() { return fullScreenSetting; }
        [[nodiscard]] bool getFullScreen() const { return fullScreenSetting.getBoolean(); }
 
        [[nodiscard]] FloatSetting& getGammaSetting() { return gammaSetting; }
        [[nodiscard]] float getGamma() const { return gammaSetting.getFloat(); }
 
        [[nodiscard]] FloatSetting& getBrightnessSetting() { return brightnessSetting; }
        [[nodiscard]] float getBrightness() const { return brightnessSetting.getFloat(); }
 
        [[nodiscard]] FloatSetting& getContrastSetting() { return contrastSetting; }
        [[nodiscard]] float getContrast() const { return contrastSetting.getFloat(); }
 
        [[nodiscard]] StringSetting& getColorMatrixSetting() { return colorMatrixSetting; }
        [[nodiscard]] bool isColorMatrixIdentity() const { return cmIdentity; }
 
        [[nodiscard]] IntegerSetting& getGlowSetting() { return glowSetting; }
        [[nodiscard]] int getGlow() const { return glowSetting.getInt(); }
 
        [[nodiscard]] FloatSetting& getNoiseSetting() { return noiseSetting; }
        [[nodiscard]] float getNoise() const { return noiseSetting.getFloat(); }
 
        [[nodiscard]] IntegerSetting& getBlurSetting() { return horizontalBlurSetting; }
        [[nodiscard]] int getBlurFactor() const {
                return (horizontalBlurSetting.getInt()) * 256 / 100;
        }
 
        [[nodiscard]] IntegerSetting& getScanlineSetting() { return scanlineAlphaSetting; }
        [[nodiscard]] int getScanlineFactor() const {
                return 255 - ((scanlineAlphaSetting.getInt() * 255) / 100);
        }
        [[nodiscard]] float getScanlineGap() const {
                return narrow<float>(scanlineAlphaSetting.getInt()) * 0.01f;
        }
 
        [[nodiscard]] RendererSetting& getRendererSetting() { return rendererSetting; }
        [[nodiscard]] RendererID getRenderer() const {
                auto r = rendererSetting.getEnum();
                return r == RendererID::UNINITIALIZED ? RendererID::DUMMY : r;
        }
 
        [[nodiscard]] auto& getScaleAlgorithmSetting() { return scaleAlgorithmSetting; }
        [[nodiscard]] ScaleAlgorithm getScaleAlgorithm() const {
                return scaleAlgorithmSetting.getEnum();
        }
 
        [[nodiscard]] IntegerSetting& getScaleFactorSetting() { return scaleFactorSetting; }
        [[nodiscard]] int getScaleFactor() const { return scaleFactorSetting.getInt(); }
 
        [[nodiscard]] BooleanSetting& getLimitSpritesSetting() { return limitSpritesSetting; }
 
        [[nodiscard]] BooleanSetting& getDisableSpritesSetting() { return disableSpritesSetting; }
        [[nodiscard]] bool getDisableSprites() const { return disableSpritesSetting.getBoolean(); }
 
        [[nodiscard]] EnumSetting<bool>& getCmdTimingSetting() { return cmdTimingSetting; }
 
        [[nodiscard]] EnumSetting<bool>& getTooFastAccessSetting() { return tooFastAccessSetting; }
 
        [[nodiscard]] auto& getDisplayDeformSetting() { return displayDeformSetting; }
        [[nodiscard]] DisplayDeform getDisplayDeform() const { return displayDeformSetting.getEnum(); }
 
        [[nodiscard]] BooleanSetting& getVSyncSetting() { return vSyncSetting; }
 
        [[nodiscard]] FloatSetting& getHorizontalStretchSetting() {
                return horizontalStretchSetting;
        }
        [[nodiscard]] float getHorizontalStretch() const {
                return horizontalStretchSetting.getFloat();
        }
 
        [[nodiscard]] FloatSetting& getPointerHideDelaySetting() {
                return pointerHideDelaySetting;
        }
        [[nodiscard]] float getPointerHideDelay() const {
                return pointerHideDelaySetting.getFloat();
        }
 
        [[nodiscard]] bool getInterleaveBlackFrame() const {
                return interleaveBlackFrameSetting.getBoolean();
        }
 
        [[nodiscard]] float transformComponent(float c) const;
 
        [[nodiscard]] gl::vec3 transformRGB(gl::vec3 rgb) const;
 
private:
        [[nodiscard]] static EnumSetting<ScaleAlgorithm>::Map getScalerMap();
        [[nodiscard]] static EnumSetting<RendererID>::Map getRendererMap();
 
        // Observer:
        void update(const Setting& setting) noexcept override;
 
        void updateBrightnessAndContrast();
 
        void parseColorMatrix(Interpreter& interp, const TclObject& value);
 
private:
        EnumSetting<Accuracy> accuracySetting;
        BooleanSetting deinterlaceSetting;
        BooleanSetting deflickerSetting;
        IntegerSetting maxFrameSkipSetting;
        IntegerSetting minFrameSkipSetting;
        BooleanSetting fullScreenSetting;
        FloatSetting gammaSetting;
        FloatSetting brightnessSetting;
        FloatSetting contrastSetting;
        StringSetting colorMatrixSetting;
        IntegerSetting glowSetting;
        FloatSetting noiseSetting;
        RendererSetting rendererSetting;
        IntegerSetting horizontalBlurSetting;
        EnumSetting<ScaleAlgorithm> scaleAlgorithmSetting;
        IntegerSetting scaleFactorSetting;
        IntegerSetting scanlineAlphaSetting;
        BooleanSetting limitSpritesSetting;
        BooleanSetting disableSpritesSetting;
        EnumSetting<bool> cmdTimingSetting;
        EnumSetting<bool> tooFastAccessSetting;
        EnumSetting<DisplayDeform> displayDeformSetting;
        BooleanSetting vSyncSetting;
        FloatSetting horizontalStretchSetting;
        FloatSetting pointerHideDelaySetting;
        BooleanSetting interleaveBlackFrameSetting;
 
        float brightness;
        float contrast;
 
        gl::mat3 colorMatrix;
        bool cmIdentity;
};
 
} // namespace openmsx
 
#endif