SDLSurfacePtr.hh

Go to the documentation of this file.

#ifndef SDLSURFACEPTR
#define SDLSURFACEPTR

#include "MemBuffer.hh"
#include <SDL.h>
#include <algorithm>
#include <new>
#include <cassert>
#include <cstdlib>

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

        SDLSurfacePtr(unsigned width, unsigned height, unsigned depth,
                      Uint32 rMask, Uint32 gMask, Uint32 bMask, Uint32 aMask)
        {
                assert((depth % 8) == 0);
                unsigned pitch = width * (depth >> 3);
                unsigned size = height * pitch;
                buffer.resize(size);
                surface = SDL_CreateRGBSurfaceFrom(
                        buffer.data(), width, height, depth, pitch,
                        rMask, gMask, bMask, aMask);
                if (!surface) throw std::bad_alloc();
        }

        explicit SDLSurfacePtr(SDL_Surface* surface_ = nullptr)
                : surface(surface_)
        {
        }

        SDLSurfacePtr(SDLSurfacePtr&& other) noexcept
                : surface(other.surface)
                , buffer(std::move(other.buffer))
        {
                other.surface = nullptr;
        }

        ~SDLSurfacePtr()
        {
                if (surface) SDL_FreeSurface(surface);
        }

        void reset(SDL_Surface* surface_ = nullptr)
        {
                SDLSurfacePtr temp(surface_);
                temp.swap(*this);
        }

        SDL_Surface* get()
        {
                return surface;
        }
        const SDL_Surface* get() const
        {
                return surface;
        }

        void swap(SDLSurfacePtr& other) noexcept
        {
                std::swap(surface, other.surface);
                std::swap(buffer,  other.buffer );
        }

        SDLSurfacePtr& operator=(SDLSurfacePtr&& other) noexcept
        {
                std::swap(surface, other.surface);
                std::swap(buffer,  other.buffer);
                return *this;
        }

        SDL_Surface& operator*()
        {
                return *surface;
        }
        const SDL_Surface& operator*() const
        {
                return *surface;
        }

        SDL_Surface* operator->()
        {
                return surface;
        }
        const SDL_Surface* operator->() const
        {
                return surface;
        }

        explicit operator bool() const
        {
                return get() != nullptr;
        }

        void* getLinePtr(unsigned y)
        {
                assert(y < unsigned(surface->h));
                return static_cast<Uint8*>(surface->pixels) + y * surface->pitch;
        }
        const void* getLinePtr(unsigned y) const
        {
                return const_cast<SDLSurfacePtr*>(this)->getLinePtr(y);
        }

private:
        SDL_Surface* surface;
        openmsx::MemBuffer<char> buffer;
};

#endif