SDLRasterizer.hh

Go to the documentation of this file.

#ifndef SDLRASTERIZER_HH
#define SDLRASTERIZER_HH

#include "Rasterizer.hh"
#include "BitmapConverter.hh"
#include "CharacterConverter.hh"
#include "SpriteConverter.hh"
#include "Observer.hh"
#include "openmsx.hh"
#include <memory>

namespace openmsx {

class Display;
class VDP;
class VDPVRAM;
class OutputSurface;
class VisibleSurface;
class RawFrame;
class RenderSettings;
class Setting;
class PostProcessor;

template <class Pixel>
class SDLRasterizer final : public Rasterizer
                          , private Observer<Setting>
{
public:
        SDLRasterizer(const SDLRasterizer&) = delete;
        SDLRasterizer& operator=(const SDLRasterizer&) = delete;

        SDLRasterizer(
                VDP& vdp, Display& display, VisibleSurface& screen,
                std::unique_ptr<PostProcessor> postProcessor);
        ~SDLRasterizer() override;

        // Rasterizer interface:
        PostProcessor* getPostProcessor() const override;
        bool isActive() override;
        void reset() override;
        void frameStart(EmuTime::param time) override;
        void frameEnd() override;
        void setDisplayMode(DisplayMode mode) override;
        void setPalette(int index, int grb) override;
        void setBackgroundColor(int index) override;
        void setHorizontalAdjust(int adjust) override;
        void setHorizontalScrollLow(byte scroll) override;
        void setBorderMask(bool masked) override;
        void setTransparency(bool enabled) override;
        void setSuperimposeVideoFrame(const RawFrame* videoSource) override;
        void drawBorder(int fromX, int fromY, int limitX, int limitY) override;
        void drawDisplay(
                int fromX, int fromY,
                int displayX, int displayY,
                int displayWidth, int displayHeight) override;
        void drawSprites(
                int fromX, int fromY,
                int displayX, int displayY,
                int displayWidth, int displayHeight) override;
        bool isRecording() const override;

private:
        inline void renderBitmapLine(Pixel* buf, unsigned vramLine);

        void resetPalette();

        void precalcPalette();

        void precalcColorIndex0(DisplayMode mode, bool transparency,
                                const RawFrame* superimposing, byte bgcolorIndex);

        // Some of the border-related settings changed.
        void borderSettingChanged();

        // Get the border color(s). These are 16bpp or 32bpp host pixels.
        void getBorderColors(Pixel& border0, Pixel& border1);

        // Observer<Setting>
        void update(const Setting& setting) override;

        VDP& vdp;

        VDPVRAM& vram;

        OutputSurface& screen;

        const std::unique_ptr<PostProcessor> postProcessor;

        std::unique_ptr<RawFrame> workFrame;

        RenderSettings& renderSettings;

        CharacterConverter<Pixel> characterConverter;

        BitmapConverter<Pixel> bitmapConverter;

        SpriteConverter<Pixel> spriteConverter;

        int lineRenderTop;

        Pixel palFg[16 * 2], palBg[16];

        Pixel palGraphic7Sprites[16];

        Pixel V9938_COLORS[8][8][8];

        Pixel PALETTE256[256];

        Pixel V9958_COLORS[32768];

        // True iff left/right border optimization can (still) be applied
        // this frame.
        bool canSkipLeftRightBorders;

        // True iff some of the left/right border related settings changed
        // during this frame (meaning the border pixels of this frame cannot
        // be reused for future frames).
        bool mixedLeftRightBorders;
};

} // namespace openmsx

#endif