SafeOpenGLImageHelper Class Reference

#include <safeopenglimagehelper.h>

Inheritance diagram for SafeOpenGLImageHelper:

Public Member Functions
	SafeOpenGLImageHelper ()
	~SafeOpenGLImageHelper ()
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)
SDL_Surface *	create32BitSurface (int width, int height) const
void	postInit ()
void	copySurfaceToImage (const Image *const image, const int x, const int y, SDL_Surface *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 RenderType	useOpenGL () const

Static Public Member Functions
static int	getTextureType ()
static int	getInternalTextureType ()
static void	setInternalTextureType (const int n)
static void	setBlur (const bool n)
static int	getTextureSize ()
static void	initTextureSampler (const GLint id)
static void	setUseTextureSampler (const bool b)
static void	invalidate (const GLuint textureId)
static void	bindTexture (const GLuint texture)
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 Public Attributes
static int	mTextureType = 0
static int	mInternalTextureType = 0x8058

Protected Member Functions
Image *	glLoad (SDL_Surface *tmpImage, int width=0, int height=0)
GLuint	getNewTexture ()
Protected Member Functions inherited from ImageHelper
	ImageHelper ()

Static Protected Member Functions
static int	powerOfTwo (const int input)
static SDL_Surface *	convertSurfaceNormalize (SDL_Surface *tmpImage, int width, int height)
static SDL_Surface *	convertSurface (SDL_Surface *tmpImage, int width, int height)

Protected Attributes
size_t	mFreeTextureIndex
GLuint	mTextures [texturesSize]

Static Protected Attributes
static const size_t	texturesSize = 10
static int	mTextureSize = 0
static bool	mBlur = true
static bool	mUseTextureSampler = false
Static Protected Attributes inherited from ImageHelper
static bool	mEnableAlpha = true
static RenderType	mUseOpenGL = RENDER_SOFTWARE

Friends
class	CompoundSprite
class	Graphics
class	Image

Detailed Description

Defines a class for loading and storing images.

Definition at line 70 of file safeopenglimagehelper.h.

Constructor & Destructor Documentation

SafeOpenGLImageHelper()

SafeOpenGLImageHelper::SafeOpenGLImageHelper ( )

inline

Definition at line 77 of file safeopenglimagehelper.h.

                                :
            mFreeTextureIndex(0U),
            mTextures()
        {
        }

~SafeOpenGLImageHelper()

SafeOpenGLImageHelper::~SafeOpenGLImageHelper

(

)

Definition at line 58 of file safeopenglimagehelper.cpp.

{
    glDeleteTextures(static_cast<GLsizei>(texturesSize - mFreeTextureIndex),
        &mTextures[mFreeTextureIndex]);
}

References mFreeTextureIndex, mTextures, and texturesSize.

Member Function Documentation

bindTexture()

void SafeOpenGLImageHelper::bindTexture ( const GLuint  texture )

static

Definition at line 255 of file safeopenglimagehelper.cpp.

{
    switch (mUseOpenGL)
    {
#ifdef __native_client__
        case RENDER_NORMAL_OPENGL:
        case RENDER_MODERN_OPENGL:
        case RENDER_GLES_OPENGL:
            break;
        case RENDER_SAFE_OPENGL:
            SafeOpenGLGraphics::bindTexture(mTextureType, texture);
            break;
        case RENDER_GLES2_OPENGL:
            MobileOpenGL2Graphics::bindTexture(mTextureType, texture);
            break;
#elif defined(ANDROID)
        case RENDER_NORMAL_OPENGL:
        case RENDER_MODERN_OPENGL:
        case RENDER_SAFE_OPENGL:
        case RENDER_GLES2_OPENGL:
            break;
        case RENDER_GLES_OPENGL:
            MobileOpenGLGraphics::bindTexture(mTextureType, texture);
            break;
#else  // __native_client__
        case RENDER_NORMAL_OPENGL:
            NormalOpenGLGraphics::bindTexture(mTextureType, texture);
            break;
        case RENDER_MODERN_OPENGL:
            ModernOpenGLGraphics::bindTexture(mTextureType, texture);
            break;
        case RENDER_SAFE_OPENGL:
            SafeOpenGLGraphics::bindTexture(mTextureType, texture);
            break;
        case RENDER_GLES_OPENGL:
            MobileOpenGLGraphics::bindTexture(mTextureType, texture);
            break;
        case RENDER_GLES2_OPENGL:
            MobileOpenGL2Graphics::bindTexture(mTextureType, texture);
            break;
#endif  // __native_client__
        case RENDER_SOFTWARE:
        case RENDER_SDL2_DEFAULT:
        case RENDER_NULL:
        case RENDER_LAST:
        default:
            logger->log("Unknown OpenGL backend: %d", mUseOpenGL);
            break;
    }
}

References bindTexture(), Logger::log(), logger, mTextureType, ImageHelper::mUseOpenGL, RENDER_GLES2_OPENGL, RENDER_GLES_OPENGL, RENDER_LAST, RENDER_MODERN_OPENGL, RENDER_NORMAL_OPENGL, RENDER_NULL, RENDER_SAFE_OPENGL, RENDER_SDL2_DEFAULT, and RENDER_SOFTWARE.

Referenced by glLoad().

convertSurface()

SDL_Surface * SafeOpenGLImageHelper::convertSurface ( SDL_Surface *  tmpImage, int  width, int  height  )

staticprotected

< Surface is in system memory

Definition at line 202 of file safeopenglimagehelper.cpp.

{
    if (tmpImage == nullptr)
        return nullptr;
 
#ifdef USE_SDL2
    SDL_SetSurfaceAlphaMod(tmpImage, SDL_ALPHA_OPAQUE);
#else  // USE_SDL2
 
    // Make sure the alpha channel is not used, but copied to destination
    SDL_SetAlpha(tmpImage, 0, SDL_ALPHA_OPAQUE);
#endif  // USE_SDL2
 
    // Determine 32-bit masks based on byte order
    uint32_t rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    rmask = 0xff000000U;
    gmask = 0x00ff0000U;
    bmask = 0x0000ff00U;
    amask = 0x000000ffU;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    rmask = 0x000000ffU;
    gmask = 0x0000ff00U;
    bmask = 0x00ff0000U;
    amask = 0xff000000U;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    if (tmpImage->format->BitsPerPixel != 32
        || rmask != tmpImage->format->Rmask
        || gmask != tmpImage->format->Gmask
        || amask != tmpImage->format->Amask)
    {
        SDL_Surface *oldImage = tmpImage;
#ifdef USE_SDL2
        SDL_SetSurfaceBlendMode(oldImage, SDL_BLENDMODE_NONE);
#endif  // USE_SDL2
 
        tmpImage = MSDL_CreateRGBSurface(SDL_SWSURFACE, width, height,
            32, rmask, gmask, bmask, amask);
 
        if (tmpImage == nullptr)
        {
            logger->log("Error, image convert failed: out of memory");
            return nullptr;
        }
        SDL_BlitSurface(oldImage, nullptr, tmpImage, nullptr);
    }
    return tmpImage;
}

References Logger::log(), logger, and MSDL_CreateRGBSurface.

Referenced by copySurfaceToImage().

convertSurfaceNormalize()

SDL_Surface * SafeOpenGLImageHelper::convertSurfaceNormalize ( SDL_Surface *  tmpImage, int  width, int  height  )

staticprotected

< Surface is in system memory

Definition at line 138 of file safeopenglimagehelper.cpp.

{
    if (tmpImage == nullptr)
        return nullptr;
 
    int realWidth = powerOfTwo(width);
    int realHeight = powerOfTwo(height);
 
    if (realWidth < width || realHeight < height)
    {
        logger->log("Warning: image too large, cropping to %dx%d texture!",
                    tmpImage->w, tmpImage->h);
    }
 
#ifdef USE_SDL2
    SDL_SetSurfaceAlphaMod(tmpImage, SDL_ALPHA_OPAQUE);
#else  // USE_SDL2
 
    // Make sure the alpha channel is not used, but copied to destination
    SDL_SetAlpha(tmpImage, 0, SDL_ALPHA_OPAQUE);
#endif  // USE_SDL2
 
    // Determine 32-bit masks based on byte order
    uint32_t rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    rmask = 0xff000000U;
    gmask = 0x00ff0000U;
    bmask = 0x0000ff00U;
    amask = 0x000000ffU;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    rmask = 0x000000ffU;
    gmask = 0x0000ff00U;
    bmask = 0x00ff0000U;
    amask = 0xff000000U;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    if (tmpImage->format->BitsPerPixel != 32
        || realWidth != width || realHeight != height
        || rmask != tmpImage->format->Rmask
        || gmask != tmpImage->format->Gmask
        || amask != tmpImage->format->Amask)
    {
        SDL_Surface *oldImage = tmpImage;
#ifdef USE_SDL2
        SDL_SetSurfaceBlendMode(oldImage, SDL_BLENDMODE_NONE);
#endif  // USE_SDL2
 
        tmpImage = MSDL_CreateRGBSurface(SDL_SWSURFACE, realWidth, realHeight,
            32, rmask, gmask, bmask, amask);
 
        if (tmpImage == nullptr)
        {
            logger->log("Error, image convert failed: out of memory");
            return nullptr;
        }
        SDL_BlitSurface(oldImage, nullptr, tmpImage, nullptr);
    }
    return tmpImage;
}

References Logger::log(), logger, MSDL_CreateRGBSurface, and powerOfTwo().

Referenced by glLoad().

copySurfaceToImage()

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

virtual

Reimplemented from ImageHelper.

Definition at line 466 of file safeopenglimagehelper.cpp.

{
    if (surface == nullptr || image == nullptr)
        return;
 
    SDL_Surface *const oldSurface = surface;
    surface = convertSurface(surface, surface->w, surface->h);
    if (surface == nullptr)
        return;
 
    // +++ probably need combine
    // mglTextureSubImage2D and mglTextureSubImage2DEXT
    if (mglTextureSubImage2D != nullptr)
    {
        mglTextureSubImage2D(image->mGLImage,
            0,
            x, y,
            surface->w, surface->h,
            GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels);
    }
    else
    {
        mglTextureSubImage2DEXT(image->mGLImage,
            mTextureType, 0,
            x, y,
            surface->w, surface->h,
            GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels);
    }
 
    if (surface != oldSurface)
        MSDL_FreeSurface(surface);
}

References convertSurface(), MSDL_FreeSurface, mTextureType, x, and y.

create32BitSurface()

SDL_Surface * SafeOpenGLImageHelper::create32BitSurface ( int  width, int  height  ) const

virtual

< Surface is in system memory

Reimplemented from ImageHelper.

Definition at line 417 of file safeopenglimagehelper.cpp.

{
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    const uint32_t rmask = 0xff000000U;
    const uint32_t gmask = 0x00ff0000U;
    const uint32_t bmask = 0x0000ff00U;
    const uint32_t amask = 0x000000ffU;
#else  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    const uint32_t rmask = 0x000000ffU;
    const uint32_t gmask = 0x0000ff00U;
    const uint32_t bmask = 0x00ff0000U;
    const uint32_t amask = 0xff000000U;
#endif  // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    width = powerOfTwo(width);
    height = powerOfTwo(height);
 
    return MSDL_CreateRGBSurface(SDL_SWSURFACE,
        width, height, 32, rmask, gmask, bmask, amask);
}

References MSDL_CreateRGBSurface, and powerOfTwo().

createTextSurface()

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

Definition at line 116 of file safeopenglimagehelper.cpp.

{
    if (tmpImage == nullptr)
        return nullptr;
 
    Image *const img = glLoad(tmpImage, width, height);
    if (img != nullptr)
        img->setAlpha(alpha);
    return img;
}

References glLoad().

getInternalTextureType()

static int SafeOpenGLImageHelper::getInternalTextureType ( )

inlinestatic

Definition at line 115 of file safeopenglimagehelper.h.

        { return mInternalTextureType; }

References mInternalTextureType.

getNewTexture()

GLuint SafeOpenGLImageHelper::getNewTexture ( )

protected

Definition at line 440 of file safeopenglimagehelper.cpp.

{
    GLuint texture = mTextures[mFreeTextureIndex];
    mFreeTextureIndex ++;
    if (mFreeTextureIndex == texturesSize)
    {
        mFreeTextureIndex = 0;
        postInit();
    }
    return texture;
}

References mFreeTextureIndex, mTextures, postInit(), and texturesSize.

Referenced by glLoad().

getTextureSize()

static int SafeOpenGLImageHelper::getTextureSize ( )

inlinestatic

Definition at line 128 of file safeopenglimagehelper.h.

        { return mTextureSize; }

References mTextureSize.

getTextureType()

static int SafeOpenGLImageHelper::getTextureType ( )

inlinestatic

Definition at line 112 of file safeopenglimagehelper.h.

        { return mTextureType; }

References mTextureType.

glLoad()

Image * SafeOpenGLImageHelper::glLoad ( SDL_Surface *  tmpImage, int  width = 0, int  height = 0  )

protected

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

< Surface is in video memory

< Use asynchronous blits if possible

< Surface is RLE encoded

Definition at line 306 of file safeopenglimagehelper.cpp.

{
    if (tmpImage == nullptr)
        return nullptr;
 
    BLOCK_START("SafeOpenGLImageHelper::glLoad")
    // Flush current error flag.
    graphicsManager.getLastError();
 
    if (width == 0)
        width = tmpImage->w;
    if (height == 0)
        height = tmpImage->h;
 
    SDL_Surface *oldImage = tmpImage;
    tmpImage = convertSurfaceNormalize(tmpImage, width, height);
    if (tmpImage == nullptr)
        return nullptr;
 
    const int realWidth = tmpImage->w;
    const int realHeight = tmpImage->h;
 
    const GLuint texture = getNewTexture();
    bindTexture(texture);
 
    if (SDL_MUSTLOCK(tmpImage))
        SDL_LockSurface(tmpImage);
 
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
    if (!mUseTextureSampler)
    {
        if (mBlur)
        {
            glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        }
        else
        {
            glTexParameteri(mTextureType, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            glTexParameteri(mTextureType, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        }
    }
#ifndef ANDROID
    glTexParameteri(mTextureType, GL_TEXTURE_MAX_LEVEL, 0);
#endif  // ANDROID
 
    glTexImage2D(mTextureType, 0, mInternalTextureType,
        tmpImage->w, tmpImage->h,
        0, GL_RGBA, GL_UNSIGNED_BYTE, tmpImage->pixels);
 
#ifdef DEBUG_OPENGL
/*
    disabled for now, because debugger can't show it
    if (isGLNotNull(mglLabelObject))
    {
        const char *const text = "image text";
        mglLabelObject(GL_TEXTURE, texture, strlen(text), text);
    }
*/
#endif  // DEBUG_OPENGL
 
/*
    GLint compressed;
    glGetTexLevelParameteriv(mTextureType, 0,
        GL_TEXTURE_COMPRESSED_ARB, &compressed);
    if (compressed)
        logger->log("image compressed");
    else
        logger->log("image not compressed");
*/
 
#ifdef DEBUG_OPENGL_LEAKS
    textures_count ++;
#endif  // DEBUG_OPENGL_LEAKS
 
    if (SDL_MUSTLOCK(tmpImage))
        SDL_UnlockSurface(tmpImage);
 
    if (oldImage != tmpImage)
        MSDL_FreeSurface(tmpImage);
 
    GLenum error = graphicsManager.getLastError();
    if (error != 0U)
    {
        std::string errmsg = GraphicsManager::errorToString(error);
        logger->log("Error: Image GL import failed: %s (%u)",
            errmsg.c_str(), error);
//        return nullptr;
    }
 
    BLOCK_END("SafeOpenGLImageHelper::glLoad")
    return new Image(texture, width, height, realWidth, realHeight);
}

References bindTexture(), BLOCK_END, BLOCK_START, convertSurfaceNormalize(), Actions::error(), GraphicsManager::errorToString(), GraphicsManager::getLastError(), getNewTexture(), graphicsManager, Image, Logger::log(), logger, mBlur, mInternalTextureType, MSDL_FreeSurface, mTextureType, mUseTextureSampler, and textures_count.

Referenced by createTextSurface(), and loadSurface().

initTextureSampler()

void SafeOpenGLImageHelper::initTextureSampler ( const GLint  id )

static

Definition at line 403 of file safeopenglimagehelper.cpp.

{
    if (mBlur)
    {
        mglSamplerParameteri(id, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        mglSamplerParameteri(id, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    }
    else
    {
        mglSamplerParameteri(id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        mglSamplerParameteri(id, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    }
}

References mBlur.

invalidate()

void SafeOpenGLImageHelper::invalidate ( const GLuint  textureId )

static

Definition at line 457 of file safeopenglimagehelper.cpp.

{
    if (isGLNotNull(mglInvalidateTexImage))
    {
        logger->log("invalidate: %u", textureId);
        mglInvalidateTexImage(textureId, 0);
    }
}

References isGLNotNull, Logger::log(), and logger.

load()

Image * SafeOpenGLImageHelper::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.

Reimplemented from ImageHelper.

Definition at line 64 of file safeopenglimagehelper.cpp.

{
    SDL_Surface *const tmpImage = loadPng(rw);
    if (tmpImage == nullptr)
    {
        logger->log("Error, image load failed: %s", SDL_GetError());
        return nullptr;
    }
 
    SDL_Surface *const surf = convertTo32Bit(tmpImage);
    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, SOGLColor)(pixels, surf->w * surf->h);
            break;
        }
        case 2:
        {
            const DyePalette *const pal = dye.getAPalete();
            if (pal != nullptr)
                DYEPALETTEP(pal, AOGLColor)(pixels, surf->w * surf->h);
            break;
        }
        case 0:
        default:
        {
            dye.normalOGLDye(pixels, surf->w * surf->h);
            break;
        }
    }
 
    Image *const image = loadSurface(surf);
    MSDL_FreeSurface(surf);
    return image;
}

References ImageHelper::convertTo32Bit(), DYEPALETTEP, Dye::getAPalete(), Dye::getSPalete(), Dye::getType(), ImageHelper::loadPng(), loadSurface(), Logger::log(), logger, MSDL_FreeSurface, and Dye::normalOGLDye().

loadSurface()

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

virtual

Loads an image from an SDL surface.

Reimplemented from ImageHelper.

Definition at line 111 of file safeopenglimagehelper.cpp.

{
    return glLoad(tmpImage);
}

References glLoad().

Referenced by load().

postInit()

void SafeOpenGLImageHelper::postInit ( )

virtual

Reimplemented from ImageHelper.

Definition at line 452 of file safeopenglimagehelper.cpp.

{
    glGenTextures(texturesSize, &mTextures[mFreeTextureIndex]);
}

References mFreeTextureIndex, mTextures, and texturesSize.

Referenced by getNewTexture().

powerOfTwo()

int SafeOpenGLImageHelper::powerOfTwo ( const int  input )

staticprotected

Returns the first power of two equal or bigger than the input.

Definition at line 130 of file safeopenglimagehelper.cpp.

{
    int value = 1;
    while (value < input && value < mTextureSize)
        value <<= 1;
    return value >= mTextureSize ? mTextureSize : value;
}

References mTextureSize.

Referenced by convertSurfaceNormalize(), and create32BitSurface().

setBlur()

static void SafeOpenGLImageHelper::setBlur ( const bool  n )

inlinestatic

Definition at line 121 of file safeopenglimagehelper.h.

        { mBlur = n; }

References mBlur.

Referenced by GraphicsManager::initGraphics().

setInternalTextureType()

static void SafeOpenGLImageHelper::setInternalTextureType ( const int  n )

inlinestatic

Definition at line 118 of file safeopenglimagehelper.h.

        { mInternalTextureType = n; }

References mInternalTextureType.

Referenced by GraphicsManager::updateTextureFormat().

setUseTextureSampler()

static void SafeOpenGLImageHelper::setUseTextureSampler ( const bool  b )

inlinestatic

Definition at line 133 of file safeopenglimagehelper.h.

        { mUseTextureSampler = b; }

References mUseTextureSampler.

Referenced by GraphicsManager::createTextureSampler().

Friends And Related Function Documentation

CompoundSprite

friend class CompoundSprite

friend

Definition at line 72 of file safeopenglimagehelper.h.

Graphics

friend class Graphics

friend

Definition at line 73 of file safeopenglimagehelper.h.

Image

friend class Image

friend

Definition at line 74 of file safeopenglimagehelper.h.

Referenced by glLoad().

Field Documentation

mBlur

bool SafeOpenGLImageHelper::mBlur = true

staticprotected

Definition at line 171 of file safeopenglimagehelper.h.

Referenced by glLoad(), initTextureSampler(), and setBlur().

mFreeTextureIndex

size_t SafeOpenGLImageHelper::mFreeTextureIndex

protected

Definition at line 167 of file safeopenglimagehelper.h.

Referenced by getNewTexture(), postInit(), and ~SafeOpenGLImageHelper().

mInternalTextureType

int SafeOpenGLImageHelper::mInternalTextureType = 0x8058

static

Definition at line 126 of file safeopenglimagehelper.h.

Referenced by getInternalTextureType(), glLoad(), and setInternalTextureType().

mTextures

GLuint SafeOpenGLImageHelper::mTextures[texturesSize]

protected

Definition at line 168 of file safeopenglimagehelper.h.

Referenced by getNewTexture(), postInit(), and ~SafeOpenGLImageHelper().

mTextureSize

int SafeOpenGLImageHelper::mTextureSize = 0

staticprotected

Definition at line 170 of file safeopenglimagehelper.h.

Referenced by getTextureSize(), powerOfTwo(), and Graphics::setOpenGLMode().

mTextureType

int SafeOpenGLImageHelper::mTextureType = 0

static

Definition at line 124 of file safeopenglimagehelper.h.

Referenced by bindTexture(), copySurfaceToImage(), drawQuad(), drawRescaledQuad(), getTextureType(), glLoad(), and Graphics::setOpenGLMode().

mUseTextureSampler

bool SafeOpenGLImageHelper::mUseTextureSampler = false

staticprotected

Definition at line 172 of file safeopenglimagehelper.h.

Referenced by glLoad(), and setUseTextureSampler().

texturesSize

const size_t SafeOpenGLImageHelper::texturesSize = 10

staticprotected

Definition at line 166 of file safeopenglimagehelper.h.

Referenced by getNewTexture(), postInit(), and ~SafeOpenGLImageHelper().

---

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

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