sdl-utils.hpp

Go to the documentation of this file.

#include "config.h"
#include "utils.hpp"

#include <iostream>
#include <sstream>
#include <algorithm>

#include <boost/shared_ptr.hpp>

#include <SDL/SDL.h>

#include <libnebular.hpp>
#include <libnebular-plugin.hpp>

#ifndef SDL_UTILS_HPP_
#define SDL_UTILS_HPP_

using boost::shared_ptr;
using std::clog;
using std::endl;

using libnebular::Picture;
using libnebular::Integer;
using libnebular::Blob;

#ifdef HAVE_SDL_SDL_H

#define CHECKZ_SDL( x ) do{                     \
    if((x) != 0) { \
    std::ostringstream tmpOut; \
    tmpOut << "SDL: \"" << SDL_GetError() << "\" at line " << __LINE__ << " of file " << __FILE__ << ": \"" << #x << "\""; \
    throw std::runtime_error(tmpOut.str()); \
} \
    }while(false)

#define CHECKNZ_SDL( x ) do{ \
    if((x) == 0) { \
    std::ostringstream tmpOut; \
    tmpOut << "SDL: \"" << SDL_GetError() << "\" at line " << __LINE__ << " of file " << __FILE__ << ": \"" << #x << "\" is 0"; \
    throw std::runtime_error(tmpOut.str()); \
} \
    }while(false)

class SdlSurfaceHolder: public shared_ptr<SDL_Surface>{
private:
    class Deleter{
    public:
        void operator()(element_type *p){
            SDL_FreeSurface( p );
        }
    };
public:
    static SdlSurfaceHolder createWithNullDeleter(SDL_Surface *hangingSurf){
        return SdlSurfaceHolder(
            hangingSurf,
            null_deleter()
        );
    }

    SdlSurfaceHolder():
        shared_ptr<SDL_Surface>(
            static_cast<SDL_Surface*>(NULL),
            Deleter()
    )
    {}

    SdlSurfaceHolder(SDL_Surface *hangingSurf):
        shared_ptr<SDL_Surface>(
            hangingSurf,
            Deleter()
        )
    {}
    template <typename CustomDeleter>
        SdlSurfaceHolder(SDL_Surface *hangingSurf, CustomDeleter customDeleter):
        shared_ptr<SDL_Surface>(
            hangingSurf,
            customDeleter
        )
    {}
    ~SdlSurfaceHolder() {}
};

class ManagerSdl{
public:

    ManagerSdl(){
        // ** Entire SDL 
        clog << "INFO: SDL Init" << endl;

        CHECKZ_SDL( SDL_Init(SDL_INIT_VIDEO) );

    }

    ~ManagerSdl(){
        clog << "INFO: SDL Cleanup" << endl;
        SDL_Quit();
    }

    void setVideoMode(Integer newScreenXSize, Integer newScreenYSize){
        const SDL_VideoInfo *info = SDL_GetVideoInfo();
        CHECKZ_SDL( info == NULL );

        clog << "INFO: Before SDL_SetVideoMode" << endl;
        CHECKNZ_SDL( SDL_SetVideoMode(
            newScreenXSize,
            newScreenYSize,
            info->vfmt->BitsPerPixel,
            SDL_RESIZABLE  | SDL_ANYFORMAT
        ));

        SdlSurfaceHolder screen = SdlSurfaceHolder::createWithNullDeleter(
            SDL_GetVideoSurface()
        );
        CHECKNZ_SDL( screen.get() );
        clog << "INFO: Video mode set: " << screen->w << "x" << screen->h << 
            " at " << Uint32(screen->format->BitsPerPixel) << " bpp" << endl;

        SDL_ShowCursor(SDL_DISABLE);
    }
};

SdlSurfaceHolder pictureToSdlSurface(Picture &src){
    if(src.get<std::string>("bm/pixel-format-type") != "rgb"){
        throw std::runtime_error(libnebular::Log::getWrongValueMsg(
            "\"bm/pixel-format-type\"", src.get<bool>("bm/pixel-format-type"), "== \"rgb\"",
            "Picture key", "Unsupported"
        ));
    }
    if(!src.get<bool>("bm/orient-top")){
        clog << "WARNING: " << libnebular::Log::getWrongValueMsg(
            "\"bm/orient-top\"", src.get<bool>("bm/orient-top"), "\"true\"",
            "Picture key", "Unsupported"
        ) << endl;
    }
    if(!src.get<bool>("bm/orient-left")){
        clog << "WARNING: " << libnebular::Log::getWrongValueMsg(
            "bm/orient-top", src.get<bool>("bm/orient-left"), "\"true\"",
            "Picture key", "Unsupported"
        ) << endl;
    }

    SdlSurfaceHolder dest(
        SDL_CreateRGBSurface(
            0,
            src.get<Integer>("bm/x-size"),
            src.get<Integer>("bm/y-size"),
            src.get<Integer>("bm/bpp"),
            src.get<Integer>("bm/pixel-mask/r"),
            src.get<Integer>("bm/pixel-mask/g"),
            src.get<Integer>("bm/pixel-mask/b"),
            src.get<Integer>("bm/pixel-mask/a")
        )
    );
    CHECKZ_SDL( isEmpty(dest) );

    const char *srcData = src.get<Blob>("bm/data").getDataReadOnly();
    char *destData = static_cast<char*>(dest->pixels);
    src.calculate<libnebular::PictureProps::PropCalcBmDataSize>();
    Integer srcPitchBits = (
        src.get<Integer>("calc/bm/scanline-pitch-bits")
    );

    if(srcPitchBits % bitsPerByte != 0){
        throw std::runtime_error(libnebular::Log::getWrongValueMsg(
            "<scanline-pitch>", srcPitchBits, "\"srcPitchBits % bitsPerByte == 0\"",
            "calculated from Picture key", "Unsupported"
        ));
    }
    Integer srcPitch = srcPitchBits / bitsPerByte;
    Integer destPitch = dest->pitch;
    Integer srcBmYSize = src.get<Integer>("bm/y-size");

    for(
        Integer y = 0;
        y < srcBmYSize;
        ++y
    ){
        std::copy(
            srcData,
            srcData+srcPitch,
            destData
        );

        srcData += srcPitch;
        destData += destPitch;
    }

    return dest;
}

#endif // HAVE_SDL_SDL_H

#endif // SDL_UTILS_HPP_

---