SDLImageHelper Class Reference

#include <sdlimagehelper.h>

Inheritance diagram for SDLImageHelper:

Public Member Functions
	SDLImageHelper ()
Image *	load (SDL_RWops *const rw, Dye const &dye)
Image *	loadSurface (SDL_Surface *const tmpImage)
Image *	createTextSurface (SDL_Surface *const tmpImage, const int width, const int height, const float alpha)
void	copySurfaceToImage (const Image *const image, const int x, const int y, SDL_Surface *const surface) const
Public Member Functions inherited from ImageHelper
virtual	~ImageHelper ()
Image *	load (SDL_RWops *const rw)
virtual Image *	createTextSurface (SDL_Surface *const tmpImage, const int width, const int height, const float alpha) const
virtual SDL_Surface *	create32BitSurface (int width, int height) const
virtual RenderType	useOpenGL () const
virtual void	postInit ()

Static Public Member Functions
static void	SDLSetEnableAlphaCache (const bool n)
static bool	SDLGetEnableAlphaCache ()
static SDL_Surface *	SDLDuplicateSurface (SDL_Surface *const tmpImage)
static int	combineSurface (SDL_Surface *const src, SDL_Rect *const srcrect, SDL_Surface *const dst, SDL_Rect *const dstrect)
Static Public Member Functions inherited from ImageHelper
static SDL_Surface *	convertTo32Bit (SDL_Surface *const tmpImage)
static void	dumpSurfaceFormat (const SDL_Surface *const image)
static void	setEnableAlpha (const bool n)
static SDL_Surface *	loadPng (SDL_RWops *const rw)
static void	setOpenGlMode (const RenderType useOpenGL)

Static Protected Member Functions
static Image *	_SDLload (SDL_Surface *tmpImage)

Static Protected Attributes
static bool	mEnableAlphaCache = false
Static Protected Attributes inherited from ImageHelper
static bool	mEnableAlpha = true
static RenderType	mUseOpenGL = RENDER_SOFTWARE

Friends
class	Image

Additional Inherited Members
Protected Member Functions inherited from ImageHelper
	ImageHelper ()

Detailed Description

Defines a class for loading and storing images.

Definition at line 43 of file sdlimagehelper.h.

Constructor & Destructor Documentation

SDLImageHelper()

SDLImageHelper::SDLImageHelper ( )

inline

Definition at line 48 of file sdlimagehelper.h.

                         :
            ImageHelper()
        { }

Member Function Documentation

_SDLload()

Image * SDLImageHelper::_SDLload ( SDL_Surface *  tmpImage )

staticprotected

SDL_Surface to SDL_Surface Image loader

Definition at line 218 of file sdlimagehelper.cpp.

{
    if (tmpImage == nullptr)
        return nullptr;
 
    bool hasAlpha = false;
    bool converted = false;
 
    if (tmpImage->format->BitsPerPixel != 32)
    {
        reportAlways("Non 32 bit image detected")
        tmpImage = convertTo32Bit(tmpImage);
 
        if (tmpImage == nullptr)
            return nullptr;
        converted = true;
    }
 
    const size_t sz = tmpImage->w * tmpImage->h;
 
    // The alpha channel to be filled with alpha values
    uint8_t *alphaChannel = new uint8_t[sz];
 
    // Figure out whether the image uses its alpha layer
    if (tmpImage->format->palette == nullptr)
    {
        const SDL_PixelFormat *const fmt = tmpImage->format;
        if (fmt->Amask != 0U)
        {
            const uint32_t amask = fmt->Amask;
            const uint8_t ashift = fmt->Ashift;
            const uint8_t aloss = fmt->Aloss;
            const uint32_t *pixels = static_cast<uint32_t*>(tmpImage->pixels);
            for (size_t i = 0; i < sz; ++ i)
            {
                const unsigned v = (pixels[i] & amask) >> ashift;
                const uint8_t a = static_cast<uint8_t>((v << aloss)
                    + (v >> (8 - (aloss << 1))));
 
                if (a != 255)
                    hasAlpha = true;
 
                alphaChannel[i] = a;
            }
        }
        else
        {
            ifconstexpr (SDL_ALPHA_OPAQUE != 255)
            {
                hasAlpha = true;
                memset(alphaChannel, SDL_ALPHA_OPAQUE, sz);
            }
        }
    }
    else
    {
        ifconstexpr (SDL_ALPHA_OPAQUE != 255)
        {
            hasAlpha = true;
            memset(alphaChannel, SDL_ALPHA_OPAQUE, sz);
        }
    }
 
    SDL_Surface *image;
 
    // Convert the surface to the current display format
    if (hasAlpha)
    {
        image = MSDL_DisplayFormatAlpha(tmpImage);
    }
    else
    {
        image = MSDL_DisplayFormat(tmpImage);
 
        // We also delete the alpha channel since
        // it's not used.
        delete [] alphaChannel;
        alphaChannel = nullptr;
    }
 
    if (image == nullptr)
    {
        reportAlways("Error: Image convert failed.")
        delete [] alphaChannel;
        return nullptr;
    }
 
    if (converted)
        MSDL_FreeSurface(tmpImage);
    return new Image(image, hasAlpha, alphaChannel);
}

References ImageHelper::convertTo32Bit(), ifconstexpr, Image, MSDL_DisplayFormat, MSDL_DisplayFormatAlpha, MSDL_FreeSurface, and reportAlways.

Referenced by loadSurface().

combineSurface()

int SDLImageHelper::combineSurface ( SDL_Surface *const  src, SDL_Rect *const  srcrect, SDL_Surface *const  dst, SDL_Rect *const  dstrect  )

static

Definition at line 310 of file sdlimagehelper.cpp.

{
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
    return SDLgfxBlitRGBA(src, srcrect, dst, dstrect);
#else  // SDL_BYTEORDER == SDL_LIL_ENDIAN
 
    return SDL_gfxBlitRGBA(src, srcrect, dst, dstrect);
#endif  // SDL_BYTEORDER == SDL_LIL_ENDIAN
}

References SDLgfxBlitRGBA().

copySurfaceToImage()

void SDLImageHelper::copySurfaceToImage ( const Image *const  image, const int  x, const int  y, SDL_Surface *const  surface  ) const

virtual

Reimplemented from ImageHelper.

Definition at line 323 of file sdlimagehelper.cpp.

{
    if ((image == nullptr) || (surface == nullptr))
        return;
 
    SDL_SetAlpha(surface, 0, SDL_ALPHA_OPAQUE);
    SDL_Rect rect =
    {
        CAST_S16(x), CAST_S16(y),
        CAST_U16(surface->w), static_cast<uint16_t>(surface->h)
    };
 
    SDL_BlitSurface(surface, nullptr, image->mSDLSurface, &rect);
}

References CAST_S16, CAST_U16, x, and y.

createTextSurface()

Image * SDLImageHelper::createTextSurface	(	SDL_Surface *const	tmpImage,
		const int	width,
		const int	height,
		const float	alpha
	)

Definition at line 142 of file sdlimagehelper.cpp.

{
    if (tmpImage == nullptr)
        return nullptr;
 
    bool hasAlpha = false;
    const size_t sz = tmpImage->w * tmpImage->h;
 
    // The alpha channel to be filled with alpha values
    uint8_t *alphaChannel = new uint8_t[sz];
 
    const SDL_PixelFormat *const fmt = tmpImage->format;
    if (fmt->Amask != 0U)
    {
        for (size_t i = 0; i < sz; ++ i)
        {
            uint32_t c = (static_cast<uint32_t*>(tmpImage->pixels))[i];
 
            const unsigned v = (c & fmt->Amask) >> fmt->Ashift;
            const uint8_t a = static_cast<uint8_t>((v << fmt->Aloss)
                + (v >> (8 - (fmt->Aloss << 1))));
 
            const uint8_t a2 = CAST_U8(
                static_cast<float>(a) * alpha);
 
            c &= ~fmt->Amask;
            c |= ((a2 >> fmt->Aloss) << fmt->Ashift & fmt->Amask);
            (static_cast<uint32_t*>(tmpImage->pixels))[i] = c;
 
            if (a != 255)
                hasAlpha = true;
 
            alphaChannel[i] = a;
        }
    }
 
    SDL_Surface *image;
 
    // Convert the surface to the current display format
    if (hasAlpha)
    {
        image = MSDL_DisplayFormatAlpha(tmpImage);
    }
    else
    {
        image = MSDL_DisplayFormat(tmpImage);
 
        // We also delete the alpha channel since
        // it's not used.
        delete [] alphaChannel;
        alphaChannel = nullptr;
    }
 
    if (image == nullptr)
    {
        reportAlways("Error: Image convert failed.")
        delete [] alphaChannel;
        return nullptr;
    }
 
    Image *const img = new Image(image, hasAlpha, alphaChannel);
    img->mAlpha = alpha;
    return img;
}

References CAST_U8, Image, MSDL_DisplayFormat, MSDL_DisplayFormatAlpha, and reportAlways.

load()

Image * SDLImageHelper::load ( SDL_RWops *const  rw, Dye const &  dye  )

virtual

Loads an image from an SDL_RWops structure and recolors it.

Parameters

rw	The SDL_RWops to load the image from.
dye	The dye used to recolor the image.

Returns

NULL if an error occurred, a valid pointer otherwise.

< Surface is in system memory

Reimplemented from ImageHelper.

Definition at line 55 of file sdlimagehelper.cpp.

{
    SDL_Surface *const tmpImage = loadPng(rw);
    if (tmpImage == nullptr)
    {
        reportAlways("Error, image load failed: %s",
            SDL_GetError())
        return nullptr;
    }
 
    SDL_PixelFormat rgba;
    rgba.palette = nullptr;
    rgba.BitsPerPixel = 32;
    rgba.BytesPerPixel = 4;
    rgba.colorkey = 0;
    rgba.alpha = 255;
    rgba.Rloss = 0;
    rgba.Gloss = 0;
    rgba.Bloss = 0;
    rgba.Aloss = 0;
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    rgba.Rmask = 0x000000FFU;
    rgba.Rshift = 24;
    rgba.Gmask = 0x0000FF00U;
    rgba.Gshift = 16;
    rgba.Bmask = 0x00FF0000U;
    rgba.Bshift = 8;
    rgba.Amask = 0xFF000000U;
    rgba.Ashift = 0;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    rgba.Rmask = 0xFF000000U;
    rgba.Rshift = 0;
    rgba.Gmask = 0x00FF0000U;
    rgba.Gshift = 8;
    rgba.Bmask = 0x0000FF00U;
    rgba.Bshift = 16;
    rgba.Amask = 0x000000FFU;
    rgba.Ashift = 24;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    // +++ here is bug on ppc64le
    SDL_Surface *const surf = MSDL_ConvertSurface(
        tmpImage, &rgba, SDL_SWSURFACE);
 
    MSDL_FreeSurface(tmpImage);
    if (surf == nullptr)
        return nullptr;
 
    uint32_t *pixels = static_cast<uint32_t *>(surf->pixels);
    const int type = dye.getType();
 
    switch (type)
    {
        case 1:
        {
            const DyePalette *const pal = dye.getSPalete();
            if (pal != nullptr)
                DYEPALETTEP(pal, SColor)(pixels, surf->w * surf->h);
            break;
        }
        case 2:
        {
            const DyePalette *const pal = dye.getAPalete();
            if (pal != nullptr)
                DYEPALETTEP(pal, AColor)(pixels, surf->w * surf->h);
            break;
        }
        case 0:
        default:
        {
            dye.normalDye(pixels, surf->w * surf->h);
            break;
        }
    }
 
    Image *const image = loadSurface(surf);
    MSDL_FreeSurface(surf);
    return image;
}

References DYEPALETTEP, Dye::getAPalete(), Dye::getSPalete(), Dye::getType(), ImageHelper::loadPng(), loadSurface(), MSDL_ConvertSurface, MSDL_FreeSurface, Dye::normalDye(), and reportAlways.

loadSurface()

Image * SDLImageHelper::loadSurface ( SDL_Surface *const  tmpImage )

virtual

Loads an image from an SDL surface.

Reimplemented from ImageHelper.

Definition at line 137 of file sdlimagehelper.cpp.

{
    return _SDLload(tmpImage);
}

References _SDLload().

Referenced by load().

SDLDuplicateSurface()

SDL_Surface * SDLImageHelper::SDLDuplicateSurface ( SDL_Surface *const  tmpImage )

static

< Surface is in system memory

Definition at line 210 of file sdlimagehelper.cpp.

{
    if ((tmpImage == nullptr) || (tmpImage->format == nullptr))
        return nullptr;
 
    return MSDL_ConvertSurface(tmpImage, tmpImage->format, SDL_SWSURFACE);
}

References MSDL_ConvertSurface.

SDLGetEnableAlphaCache()

static bool SDLImageHelper::SDLGetEnableAlphaCache ( )

inlinestatic

Definition at line 85 of file sdlimagehelper.h.

        { return mEnableAlphaCache; }

References mEnableAlphaCache.

SDLSetEnableAlphaCache()

static void SDLImageHelper::SDLSetEnableAlphaCache ( const bool  n )

inlinestatic

Definition at line 82 of file sdlimagehelper.h.

        { mEnableAlphaCache = n; }

References mEnableAlphaCache.

Friends And Related Function Documentation

Image

friend class Image

friend

Definition at line 45 of file sdlimagehelper.h.

Referenced by _SDLload(), and createTextSurface().

Field Documentation

mEnableAlphaCache

bool SDLImageHelper::mEnableAlphaCache = false

staticprotected

Definition at line 100 of file sdlimagehelper.h.

Referenced by SDLGetEnableAlphaCache(), and SDLSetEnableAlphaCache().

---

The documentation for this class was generated from the following files:

• src/resources/sdlimagehelper.h (986a3bf)
• src/resources/sdlimagehelper.cpp (986a3bf)