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 RawFrame;
class RenderSettings;
class Setting;
class PostProcessor;
 
template<typename Pixel>
class SDLRasterizer final : public Rasterizer
                          , private Observer<Setting>
{
public:
        SDLRasterizer(const SDLRasterizer&) = delete;
        SDLRasterizer& operator=(const SDLRasterizer&) = delete;
 
        SDLRasterizer(
                VDP& vdp, Display& display, OutputSurface& screen,
                std::unique_ptr<PostProcessor> postProcessor);
        ~SDLRasterizer() override;
 
        // Rasterizer interface:
        [[nodiscard]] PostProcessor* getPostProcessor() const override;
        [[nodiscard]] 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;
        [[nodiscard]] 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;
 
private:
        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