SDLSurfacePtr.hh

Go to the documentation of this file.

#ifndef SDLSURFACEPTR
#define SDLSURFACEPTR

#include <SDL.h>
#include <algorithm>
#include <new>
#include <cassert>
#include <cstdlib>

class SDLSurfacePtr
{
public:
        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 = malloc(size);
                if (!buffer) throw std::bad_alloc();
                surface = SDL_CreateRGBSurfaceFrom(
                        buffer, width, height, depth, pitch,
                        rMask, gMask, bMask, aMask);
                if (!surface) {
                        free(buffer);
                        throw std::bad_alloc();
                }
        }

        // don't allow copy and assign
        // msvc doesn't yet support deleted functions.
        SDLSurfacePtr(const SDLSurfacePtr&) /*= delete*/;
        SDLSurfacePtr& operator=(const SDLSurfacePtr&) /*= delete*/;

        explicit SDLSurfacePtr(SDL_Surface* surface_ = nullptr,
                               void* buffer_ = nullptr)
                : surface(surface_)
                , buffer(buffer_)
        {
        }

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

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

        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)
        {
                std::swap(surface, other.surface);
                std::swap(buffer,  other.buffer );
        }

        SDLSurfacePtr& operator=(SDLSurfacePtr&& other)
        {
                SDLSurfacePtr tmp(other.surface, other.buffer);
                other.surface = nullptr;
                other.buffer = nullptr;
                tmp.swap(*this);
                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;
        }

        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;
        void* buffer;
};

#endif