/*
* The ManaPlus Client
* Copyright (C) 2004-2009 The Mana World Development Team
* Copyright (C) 2009-2010 The Mana Developers
* Copyright (C) 2011 The ManaPlus Developers
*
* This file is part of The ManaPlus Client.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef IMAGE_H
#define IMAGE_H
#include "main.h"
#include "resources/resource.h"
#include <SDL.h>
#ifdef USE_OPENGL
/* The definition of OpenGL extensions by SDL is giving problems with recent
* gl.h headers, since they also include these definitions. As we're not using
* extensions anyway it's safe to just disable the SDL version.
*/
#define NO_SDL_GLEXT
#include <SDL_opengl.h>
#endif
#include <map>
class Dye;
struct Position;
/**
* Defines a class for loading and storing images.
*/
class Image : public Resource
{
friend class CompoundSprite;
friend class Graphics;
#ifdef USE_OPENGL
friend class OpenGLGraphics;
friend class OpenGL1Graphics;
#endif
public:
/**
* Destructor.
*/
virtual ~Image();
/**
* Loads an image from a buffer in memory.
*
* @param buffer The memory buffer containing the image data.
* @param bufferSize The size of the memory buffer in bytes.
*
* @return <code>NULL</code> if an error occurred, a valid pointer
* otherwise.
*/
static Resource *load(void *buffer, unsigned bufferSize);
/**
* Loads an image from a buffer in memory and recolors it.
*
* @param buffer The memory buffer containing the image data.
* @param bufferSize The size of the memory buffer in bytes.
* @param dye The dye used to recolor the image.
*
* @return <code>NULL</code> if an error occurred, a valid pointer
* otherwise.
*/
static Resource *load(void *buffer, unsigned bufferSize,
Dye const &dye);
/**
* Loads an image from an SDL surface.
*/
static Image *load(SDL_Surface *);
static SDL_Surface* convertTo32Bit(SDL_Surface* tmpImage);
static Image *createTextSurface(SDL_Surface *tmpImage, float alpha);
/**
* Frees the resources created by SDL.
*/
virtual void unload();
/**
* Tells is the image is loaded
*/
bool isLoaded()
{ return mLoaded; }
/**
* Returns the width of the image.
*/
inline int getWidth() const // was virtual
{ return mBounds.w; }
/**
* Returns the height of the image.
*/
inline int getHeight() const // was virtual
{ return mBounds.h; }
/**
* Tells if the image was loaded using OpenGL or SDL
* @return true if OpenGL, false if SDL.
*/
int useOpenGL() const;
/**
* Tells if the image has got an alpha channel
* @return true if it's true, false otherwise.
*/
bool hasAlphaChannel();
/**
* Sets the alpha value of this image.
*/
virtual void setAlpha(float alpha);
/**
* Returns the alpha value of this image.
*/
float getAlpha() const
{ return mAlpha; }
/**
* Creates a new image with the desired clipping rectangle.
*
* @return <code>NULL</code> if creation failed and a valid
* object otherwise.
*/
virtual Image *getSubImage(int x, int y, int width, int height);
// SDL only public functions
/**
* Gets an scaled instance of an image.
*
* @param width The desired width of the scaled image.
* @param height The desired height of the scaled image.
*
* @return A new Image* object.
*/
Image* SDLgetScaledImage(int width, int height);
/**
* Merges two image SDL_Surfaces together. This is for SDL use only, as
* reducing the number of surfaces that SDL has to render can cut down
* on the number of blit operations necessary, which in turn can help
* improve overall framerates. Don't use unless you are using it to
* reduce the number of overall layers that need to be drawn through SDL.
*/
Image *SDLmerge(Image *image, int x, int y);
/**
* Get the alpha Channel of a SDL surface.
*/
Uint8 *SDLgetAlphaChannel() const
{ return mAlphaChannel; }
SDL_Surface* SDLDuplicateSurface(SDL_Surface* tmpImage);
void SDLCleanCache();
void SDLTerminateAlphaCache();
static void SDLSetEnableAlphaCache(bool n)
{ mEnableAlphaCache = n; }
static void setEnableAlpha(bool n)
{ mEnableAlpha = n; }
#ifdef USE_OPENGL
// OpenGL only public functions
/**
* Sets the target image format. Use <code>false</code> for SDL and
* <code>true</code> for OpenGL.
*/
static void setLoadAsOpenGL(int useOpenGL);
static int getLoadAsOpenGL()
{ return mUseOpenGL; }
int getTextureWidth() const
{ return mTexWidth; }
int getTextureHeight() const
{ return mTexHeight; }
static int getTextureType()
{ return mTextureType; }
static int mTextureType;
#endif
bool isHasAlphaChannel()
{ return mHasAlphaChannel; }
bool isAlphaVisible()
{ return mIsAlphaVisible; }
void setAlphaVisible(bool b)
{ mIsAlphaVisible = b; }
bool isAlphaCalculated()
{ return mIsAlphaCalculated; }
void setAlphaCalculated(bool b)
{ mIsAlphaCalculated = b; }
SDL_Rect mBounds;
protected:
// -----------------------
// Generic protected members
// -----------------------
bool mLoaded;
float mAlpha;
bool mHasAlphaChannel;
// -----------------------
// SDL protected members
// -----------------------
/** SDL Constructor */
Image(SDL_Surface *image, bool hasAlphaChannel = false,
Uint8 *alphaChannel = NULL);
/** SDL_Surface to SDL_Surface Image loader */
static Image *_SDLload(SDL_Surface *tmpImage);
SDL_Surface *getByAlpha(float alpha);
SDL_Surface *mSDLSurface;
/** Alpha Channel pointer used for 32bit based SDL surfaces */
Uint8 *mAlphaChannel;
std::map<float, SDL_Surface*> mAlphaCache;
bool mUseAlphaCache;
bool mIsAlphaVisible;
bool mIsAlphaCalculated;
static bool mEnableAlphaCache;
static bool mEnableAlpha;
// -----------------------
// OpenGL protected members
// -----------------------
#ifdef USE_OPENGL
/**
* OpenGL Constructor.
*/
Image(GLuint glimage, int width, int height,
int texWidth, int texHeight);
/**
* Returns the first power of two equal or bigger than the input.
*/
static int powerOfTwo(int input);
static Image *_GLload(SDL_Surface *tmpImage);
GLuint mGLImage;
int mTexWidth, mTexHeight;
static int mUseOpenGL;
static int mTextureSize;
#endif
};
/**
* A clipped version of a larger image.
*/
class SubImage : public Image
{
public:
/**
* Constructor.
*/
SubImage(Image *parent, SDL_Surface *image,
int x, int y, int width, int height);
#ifdef USE_OPENGL
SubImage(Image *parent, GLuint image, int x, int y,
int width, int height, int texWidth, int textHeight);
#endif
/**
* Destructor.
*/
~SubImage();
/**
* Creates a new image with the desired clipping rectangle.
*
* @return <code>NULL</code> if creation failed and a valid
* image otherwise.
*/
Image *getSubImage(int x, int y, int width, int height);
SDL_Rect mInternalBounds;
private:
Image *mParent;
};
#endif
