OutputSurface.hh

Go to the documentation of this file.

#ifndef OUTPUTSURFACE_HH
#define OUTPUTSURFACE_HH

#include "gl_vec.hh"
#include <string>
#include <cassert>
#include <SDL.h>

namespace openmsx {

class OutputSurface
{
public:
        OutputSurface(const OutputSurface&) = delete;
        OutputSurface& operator=(const OutputSurface&) = delete;

        virtual ~OutputSurface() = default;

        int getWidth()  const { return surface->w; }
        int getHeight() const { return surface->h; }
        gl::ivec2 getLogicalSize()  const { return {getWidth(), getHeight()}; }
        gl::ivec2 getPhysicalSize() const { return m_physSize; }

        gl::ivec2 getViewOffset() const { return m_viewOffset; }
        gl::ivec2 getViewSize()   const { return m_viewSize; }
        gl::vec2  getViewScale()  const { return m_viewScale; }
        bool      isViewScaled()  const { return m_viewScale != gl::vec2(1.0f); }

        const SDL_PixelFormat& getSDLFormat() const { return format; }
        SDL_Surface* getSDLSurface()          const { return surface; }
        SDL_Renderer* getSDLRenderer()        const { return renderer; }

        unsigned mapRGB(gl::vec3 rgb)
        {
                return mapRGB255(gl::ivec3(rgb * 255.0f));
        }

        unsigned mapRGB255(gl::ivec3 rgb)
        {
                return SDL_MapRGB(&format, rgb[0], rgb[1], rgb[2]); // alpha is fully opaque
        }

        template<typename Pixel> inline Pixel getKeyColor() const
        {
                return sizeof(Pixel) == 2
                        ? 0x0001      // lowest bit of 'some' color component is set
                        : 0x00000000; // alpha = 0
        }

        template<typename Pixel> inline Pixel getKeyColorClash() const
        {
                assert(sizeof(Pixel) != 4); // shouldn't get clashes in 32bpp
                return 0; // is visually very close, practically
                          // indistinguishable, from the actual KeyColor
        }

        template<typename Pixel> Pixel mapKeyedRGB255(gl::ivec3 rgb)
        {
                Pixel p = mapRGB255(rgb);
                if (sizeof(Pixel) == 2) {
                        return (p != getKeyColor<Pixel>())
                                ? p
                                : getKeyColorClash<Pixel>();
                } else {
                        assert(p != getKeyColor<Pixel>());
                        return p;
                }
        }

        template<typename Pixel> Pixel mapKeyedRGB(gl::vec3 rgb)
        {
                return mapKeyedRGB255<Pixel>(gl::ivec3(rgb * 255.0f));
        }

        void lock();

        void unlock();

        bool isLocked() const { return locked; }

        template <typename Pixel>
        Pixel* getLinePtrDirect(unsigned y) {
                assert(isLocked());
                return reinterpret_cast<Pixel*>(data + y * pitch);
        }

        virtual void flushFrameBuffer();

        virtual void saveScreenshot(const std::string& filename) = 0;

        virtual void clearScreen();

protected:
        OutputSurface() = default;

        void calculateViewPort(gl::ivec2 physSize);
        void setSDLSurface(SDL_Surface* surface_) { surface = surface_; }
        void setSDLRenderer(SDL_Renderer* r) { renderer = r; }
        void setSDLFormat(const SDL_PixelFormat& format);
        void setBufferPtr(char* data, unsigned pitch);

private:
        SDL_Surface* surface = nullptr;
        SDL_Renderer* renderer = nullptr;
        SDL_PixelFormat format;
        char* data;
        unsigned pitch;
        gl::ivec2 m_physSize;
        gl::ivec2 m_viewOffset;
        gl::ivec2 m_viewSize;
        gl::vec2 m_viewScale{1.0f};

        bool locked = false;
};

} // namespace openmsx

#endif