RenderSettings.hh

Go to the documentation of this file.

#ifndef RENDERSETTINGS_HH
#define RENDERSETTINGS_HH

#include "RendererFactory.hh"
#include "Observer.hh"
#include "noncopyable.hh"
#include <string>
#include <memory>

namespace openmsx {

class CommandController;
class Setting;
class IntegerSetting;
class FloatSetting;
class BooleanSetting;
class StringSetting;
class VideoSourceSetting;
class ColorMatrixChecker;

class RenderSettings : private Observer<Setting>, private noncopyable
{
public:
        enum Accuracy { ACC_SCREEN, ACC_LINE, ACC_PIXEL };

        enum ScaleAlgorithm {
                SCALER_SIMPLE, SCALER_SAI, SCALER_SCALE,
                SCALER_HQ, SCALER_HQLITE, SCALER_RGBTRIPLET, SCALER_TV, SCALER_MLAA
        };

        enum DisplayDeform {
                DEFORM_NORMAL, DEFORM_3D
        };

        explicit RenderSettings(CommandController& commandController);
        ~RenderSettings();

        EnumSetting<Accuracy>& getAccuracy() const { return *accuracySetting; }

        BooleanSetting& getDeinterlace() const { return *deinterlaceSetting; }

        IntegerSetting& getMaxFrameSkip() const { return *maxFrameSkipSetting; }

        IntegerSetting& getMinFrameSkip() const { return *minFrameSkipSetting; }

        BooleanSetting& getFullScreen() const { return *fullScreenSetting; }

        FloatSetting& getGamma() const { return *gammaSetting; }

        FloatSetting& getBrightness() const { return *brightnessSetting; }

        FloatSetting& getContrast() const { return *contrastSetting; }

        StringSetting& getColorMatrix() const { return *colorMatrixSetting; }

        bool isColorMatrixIdentity() const { return cmIdentity; }

        IntegerSetting& getGlow() const { return *glowSetting; }

        FloatSetting& getNoise() const { return *noiseSetting; }

        int getBlurFactor() const;

        int getScanlineFactor() const;

        float getScanlineGap() const;

        RendererFactory::RendererSetting& getRenderer() const {
                return *rendererSetting;
        }

        EnumSetting<ScaleAlgorithm>& getScaleAlgorithm() const {
                return *scaleAlgorithmSetting;
        }

        IntegerSetting& getScaleFactor() const { return *scaleFactorSetting; }

        BooleanSetting& getLimitSprites() const { return *limitSpritesSetting; }

        BooleanSetting& getDisableSprites() const { return *disableSpritesSetting; }

        EnumSetting<bool>& getCmdTiming() const { return *cmdTimingSetting; }

        EnumSetting<DisplayDeform>& getDisplayDeform() const {
                return *displayDeformSetting;
        }

        FloatSetting& getHorizontalStretch() const {
                return *horizontalStretchSetting;
        }

        FloatSetting& getPointerHideDelay() const {
                return *pointerHideDelaySetting;
        }

        double transformComponent(double c) const;

        void transformRGB(double& r, double& g, double& b) const;

private:
        // Observer:
        void update(const Setting&);

        void updateBrightnessAndContrast();

        void parseColorMatrix(const std::string& value);

        std::unique_ptr<EnumSetting<Accuracy>> accuracySetting;
        std::unique_ptr<EnumSetting<bool>> cmdTimingSetting;
        std::unique_ptr<BooleanSetting> deinterlaceSetting;
        std::unique_ptr<BooleanSetting> fullScreenSetting;
        std::unique_ptr<FloatSetting> gammaSetting;
        std::unique_ptr<FloatSetting> brightnessSetting;
        std::unique_ptr<FloatSetting> contrastSetting;
        std::unique_ptr<ColorMatrixChecker> colorMatrixChecker;
        std::unique_ptr<StringSetting> colorMatrixSetting;
        std::unique_ptr<IntegerSetting> glowSetting;
        std::unique_ptr<FloatSetting> noiseSetting;
        std::unique_ptr<IntegerSetting> horizontalBlurSetting;
        std::unique_ptr<BooleanSetting> limitSpritesSetting;
        std::unique_ptr<BooleanSetting> disableSpritesSetting;
        std::unique_ptr<IntegerSetting> maxFrameSkipSetting;
        std::unique_ptr<IntegerSetting> minFrameSkipSetting;
        std::unique_ptr<RendererFactory::RendererSetting> rendererSetting;
        std::unique_ptr<EnumSetting<ScaleAlgorithm>> scaleAlgorithmSetting;
        std::unique_ptr<IntegerSetting> scaleFactorSetting;
        std::unique_ptr<IntegerSetting> scanlineAlphaSetting;
        std::unique_ptr<EnumSetting<DisplayDeform>> displayDeformSetting;
        std::unique_ptr<FloatSetting> horizontalStretchSetting;
        std::unique_ptr<FloatSetting> pointerHideDelaySetting;

        double brightness;
        double contrast;

        double cm[3][3];
        bool cmIdentity;

        friend class ColorMatrixChecker;
};

} // namespace openmsx

#endif