video/Surface.h

Go to the documentation of this file.

#ifndef SDL_VIDEO_SURFACE_H
#define SDL_VIDEO_SURFACE_H

#include <string>
#include <stdexcept>

#include <boost/shared_ptr.hpp>

#include <SDL.h>

#include "sdlpp/misc/Rect.h"
#include "sdlpp/misc/Color.h"

namespace sdl {
namespace video {
    using namespace std;
    using namespace misc;

    class Surface {
        public:
            Surface () : surface_ (SDL_GetVideoSurface (), &SDL_FreeSurface) {
                if (surface_ == NULL)
                    throw runtime_error (SDL_GetError ());
            };

            Surface (SDL_Surface* surface) : surface_ (surface, &SDL_FreeSurface) {
                if (surface_ == NULL)
                    throw runtime_error (SDL_GetError ());
            };

            Surface (const string& fileName) : surface_ (SDL_LoadBMP (fileName.c_str ()), &SDL_FreeSurface) {
                if (surface_ == NULL)
                    throw runtime_error (SDL_GetError ());
            };

            Surface (int height, int width, int bpp, unsigned int flags)
              : surface_ (SDL_SetVideoMode (height, width, bpp, flags)) {
                if (surface_ == NULL)
                    throw runtime_error (SDL_GetError ());
            };

            Surface (Uint32 flags, const Rect& rect, int bpp, const Color& mask)
              : surface_ (SDL_CreateRGBSurface (flags, rect.width (), rect.height (), bpp, 
                                                mask.red (), mask.green (), mask.blue (), mask.alpha ()), 
                                                &SDL_FreeSurface) {
                if (surface_ == NULL)
                    throw runtime_error (SDL_GetError ());
            };

            Surface (void *pixels, const Rect& rect, int bpp, int pitch, const Color& mask)
              : surface_ (SDL_CreateRGBSurfaceFrom (pixels, rect.width (), rect.height (), bpp, pitch, 
                                                    mask.red (), mask.green (), mask.blue (), mask.alpha ()), 
                                                    &SDL_FreeSurface) {
                if (surface_ == NULL)
                    throw runtime_error (SDL_GetError ());
            };

            ~Surface () {};

            Surface (const Surface& rhs) : surface_ (rhs.surface_) {};
            
            Surface& operator= (const Surface& rhs) {
                if (this != &rhs) 
                    surface_ = rhs.surface_;
                return *this;
            };

            Surface& blit (Surface& surface, const Rect& srcRect, const Rect& dstRect) {
                SDL_Rect src;
                src.w = srcRect.width ();
                src.h = srcRect.height ();
                src.x = srcRect.x ();
                src.y = srcRect.y ();
                SDL_Rect dst;
                dst.w = dstRect.width ();
                dst.h = dstRect.height ();
                dst.x = dstRect.x ();
                dst.y = dstRect.y ();
                if (SDL_BlitSurface (surface.to_c (), &src, surface_.get (), &dst) == -1)
                    throw runtime_error (SDL_GetError ());
                return *this;
            };

            int height () { return surface_->h; };

            int width () { return surface_->w; };

            int bpp () { return surface_->format->BitsPerPixel; };

            bool lock () { return SDL_LockSurface (surface_.get ()) == 0; };

            void unlock () { SDL_UnlockSurface (surface_.get ()); };

            bool save (const string& fileName) { return SDL_SaveBMP (surface_.get (), fileName.c_str ()) == 0; };
             
            SDL_Surface* const to_c () const { return surface_.get (); };

        private:
            boost::shared_ptr<SDL_Surface> surface_;
    }; //Surface
}; //video
}; //sdl

#endif //SDL_VIDEO_SURFACE_H