OutputSurface.hh

Go to the documentation of this file.

#ifndef OUTPUTSURFACE_HH
#define OUTPUTSURFACE_HH
 
#include "PixelFormat.hh"
#include "gl_vec.hh"
#include <string>
#include <cassert>
#include <cstdint>
 
namespace openmsx {
 
class OutputSurface
{
public:
        OutputSurface(const OutputSurface&) = delete;
        OutputSurface& operator=(const OutputSurface&) = delete;
 
        virtual ~OutputSurface() = default;
 
        int getLogicalWidth()  const { return m_logicalSize[0]; }
        int getLogicalHeight() const { return m_logicalSize[1]; }
        gl::ivec2 getLogicalSize()  const { return m_logicalSize; }
        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 PixelFormat& getPixelFormat() const { return pixelFormat; }
 
        uint32_t mapRGB(gl::vec3 rgb) const
        {
                return mapRGB255(gl::ivec3(rgb * 255.0f));
        }
 
        uint32_t mapRGB255(gl::ivec3 rgb) const
        {
                auto [r, g, b] = rgb;
                return getPixelFormat().map(r, g, b);
        }
 
        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));
        }
 
        virtual void saveScreenshot(const std::string& filename) = 0;
 
protected:
        OutputSurface() = default;
 
        // These two _must_ be called from (each) subclass constructor.
        void calculateViewPort(gl::ivec2 logSize, gl::ivec2 physSize);
        void setPixelFormat(const PixelFormat& format) { pixelFormat = format; }
        void setOpenGlPixelFormat();
 
private:
        PixelFormat pixelFormat;
        gl::ivec2 m_logicalSize;
        gl::ivec2 m_physSize;
        gl::ivec2 m_viewOffset;
        gl::ivec2 m_viewSize;
        gl::vec2 m_viewScale{1.0f};
};
 
} // namespace openmsx
 
#endif