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 <array>
#include <concepts>
#include <memory>
 
namespace openmsx {
 
class Display;
class VDP;
class VDPVRAM;
class OutputSurface;
class RawFrame;
class RenderSettings;
class Setting;
class PostProcessor;
 
template<std::unsigned_integral 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(unsigned index, int grb) override;
        void setBackgroundColor(byte 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(std::span<Pixel> buf, unsigned vramLine);
 
        void resetPalette();
 
        void precalcPalette();
 
        void precalcColorIndex0(DisplayMode mode, bool transparency,
                                const RawFrame* superimposing, byte bgcolorIndex);
 
        // Get the border color(s). These are 16bpp or 32bpp host pixels.
        std::pair<Pixel, Pixel> getBorderColors();
 
        // Observer<Setting>
        void update(const Setting& setting) noexcept 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;
 
        std::array<Pixel, 16 * 2> palFg;
        std::array<Pixel, 16> palBg;
 
        std::array<Pixel, 16> palGraphic7Sprites;
 
        std::array<std::array<std::array<Pixel, 8>, 8>, 8> V9938_COLORS;
 
        std::array<Pixel, 256> PALETTE256;
 
        std::array<Pixel, 32768> V9958_COLORS;
};
 
} // namespace openmsx
 
#endif