570 lines
17 KiB
C++
570 lines
17 KiB
C++
/*******************************************************************************
|
|
This file is Part of the ZEngine Library for 2D game development.
|
|
Copyright (C) 2002, 2003 James Turk
|
|
|
|
Licensed under a BSD-style license.
|
|
|
|
The maintainer of this library is James Turk (james@conceptofzero.net)
|
|
and the home of this Library is http://www.zengine.sourceforge.net
|
|
*******************************************************************************/
|
|
|
|
/**
|
|
\file ZE_ZImage.cpp
|
|
\brief Source file for ZImage.
|
|
|
|
Implementation of ZImage, the Image class for ZEngine.
|
|
<br>$Id: ZE_ZImage.cpp,v 1.47 2003/09/24 02:03:18 cozman Exp $<br>
|
|
\author James Turk
|
|
**/
|
|
|
|
#include "ZE_ZImage.h"
|
|
|
|
namespace ZE
|
|
{
|
|
|
|
ZImage::ZImage() :
|
|
rEngine(ZEngine::GetInstance()),
|
|
rImage(NULL),
|
|
rAlpha(255)
|
|
{
|
|
Release();
|
|
}
|
|
|
|
ZImage::ZImage(const ZImage &rhs) :
|
|
rEngine(ZEngine::GetInstance()),
|
|
rImage(NULL),
|
|
rAlpha(rhs.Alpha())
|
|
{
|
|
OpenFromImage(rhs.Surface(),0,0,(Sint16)rhs.Width(),(Sint16)rhs.Height());
|
|
}
|
|
|
|
ZImage::ZImage(std::string filename) :
|
|
rEngine(ZEngine::GetInstance()),
|
|
rImage(NULL),
|
|
rAlpha(255)
|
|
{
|
|
Open(filename);
|
|
}
|
|
|
|
ZImage::ZImage(SDL_Surface *surface) :
|
|
rEngine(ZEngine::GetInstance()),
|
|
rImage(NULL),
|
|
rAlpha(255)
|
|
{
|
|
Attach(surface);
|
|
}
|
|
|
|
ZImage::ZImage(SDL_Surface *img, Sint16 x, Sint16 y, Sint16 w, Sint16 h) :
|
|
rEngine(ZEngine::GetInstance()),
|
|
rImage(NULL),
|
|
rAlpha(255)
|
|
{
|
|
OpenFromImage(img,x,y,w,h);
|
|
}
|
|
|
|
ZImage::ZImage(const ZImage &img, Sint16 x, Sint16 y, Sint16 w, Sint16 h) :
|
|
rEngine(ZEngine::GetInstance()),
|
|
rImage(NULL),
|
|
rAlpha(255)
|
|
{
|
|
OpenFromImage(img.Surface(),x,y,w,h); //call SDL_Surface* version instead of taking the long way
|
|
}
|
|
|
|
ZImage::~ZImage()
|
|
{
|
|
Release();
|
|
}
|
|
|
|
void ZImage::Open(std::string filename)
|
|
{
|
|
SDL_Surface *image;
|
|
|
|
#ifdef USE_SDL_IMAGE
|
|
image = IMG_Load(filename.c_str());
|
|
#else
|
|
image = SDL_LoadBMP(filename.c_str());
|
|
#endif //USE_SDL_IMAGE
|
|
|
|
if(!image)
|
|
rEngine->ReportError(ZERR_LOAD_IMAGE,filename);
|
|
else
|
|
Attach(image);
|
|
}
|
|
|
|
void ZImage::OpenFromZip(std::string zipname, std::string filename)
|
|
{
|
|
SDL_Surface *image=NULL;
|
|
SDL_RWops *rw;
|
|
|
|
rw = RWFromZip(zipname,filename);
|
|
|
|
if(rw)
|
|
{
|
|
#ifdef USE_SDL_IMAGE
|
|
image = IMG_Load_RW(rw,0);
|
|
#else
|
|
image = SDL_LoadBMP_RW(rw,0);
|
|
#endif //USE_SDL_IMAGE
|
|
delete []rw->hidden.mem.base; //must free buffer
|
|
SDL_FreeRW(rw);
|
|
}
|
|
|
|
if(!image)
|
|
rEngine->ReportError(ZERR_LOAD_IMAGE,FormatStr("%s in %s archive",filename.c_str(),zipname.c_str()));
|
|
else
|
|
Attach(image);
|
|
}
|
|
|
|
void ZImage::OpenFromImage(SDL_Surface *image, Sint16 x, Sint16 y, Sint16 w, Sint16 h)
|
|
{
|
|
SDL_Surface *screen = rEngine->Display();
|
|
SDL_Surface *cutImg = NULL;
|
|
SDL_Rect rect;
|
|
SDL_VideoInfo *videoInfo;
|
|
|
|
//either set hardware or software surface//
|
|
videoInfo = const_cast<SDL_VideoInfo*>(SDL_GetVideoInfo());
|
|
|
|
rect.x = x;
|
|
rect.y = y;
|
|
rect.w = w;
|
|
rect.h = h;
|
|
|
|
if(!image)
|
|
rEngine->ReportError(ZERR_NOIMAGE,"OpenFromImage");
|
|
|
|
cutImg = SDL_CreateRGBSurface(0, rect.w, rect.h, rEngine->DisplayDepth(),
|
|
screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
|
|
|
|
if(!cutImg)
|
|
rEngine->ReportError(ZERR_SDL_INTERNAL,FormatStr("SDL_CreateRGBSurface failed in ZImage::OpenFromImage: %s.",SDL_GetError()));
|
|
|
|
SDL_BlitSurface(image,&rect,cutImg,NULL);
|
|
Attach(cutImg);
|
|
}
|
|
|
|
void ZImage::OpenFromImage(const ZImage &img, Sint16 x, Sint16 y, Sint16 w, Sint16 h)
|
|
{
|
|
OpenFromImage(img.Surface(),x,y,w,h);
|
|
}
|
|
|
|
#if (GFX_BACKEND == ZE_OGL)
|
|
|
|
//attach is really the core of ZImage, everything calls it, it converts SDL_Surface->OpenGL Texture->ZImage
|
|
void ZImage::Attach(SDL_Surface *surface)
|
|
{
|
|
GLfloat coord[4];
|
|
|
|
Release(); //avoid most user inflicted memory leaks associated with ZImage
|
|
|
|
//surface conversion//
|
|
SDL_Surface *temp = surface;
|
|
surface = SDL_DisplayFormatAlpha(temp); //TTF_RenderTextBlended relys on this
|
|
if(surface)
|
|
{
|
|
FreeImage(temp);
|
|
}
|
|
else //can't convert
|
|
{
|
|
rEngine->ReportError(ZERR_SDL_INTERNAL,FormatStr("SDL_DisplayFormatAlpha failed in ZImage::Attach: %s",SDL_GetError()));
|
|
surface = temp;
|
|
}
|
|
|
|
if(surface)
|
|
{
|
|
rWidth = static_cast<float>(surface->w);
|
|
rHeight = static_cast<float>(surface->h);
|
|
rTexID = SDL_GL_LoadTexture(surface,coord); //major helper, not written by me, from libsdl.org
|
|
rTexMinX = coord[0];
|
|
rTexMinY = coord[1];
|
|
rTexMaxX = coord[2];
|
|
rTexMaxY = coord[3];
|
|
rImage = surface;
|
|
}
|
|
else
|
|
rEngine->ReportError(ZERR_NOIMAGE,"Attach");
|
|
}
|
|
|
|
void ZImage::Reload()
|
|
{
|
|
//this little hack helps to reload images to OpenGL surfaces after loss
|
|
SDL_Surface *temp = rImage;
|
|
rImage = NULL;
|
|
Attach(temp);
|
|
}
|
|
|
|
void ZImage::Release()
|
|
{
|
|
//set everything back the way it came
|
|
if(glIsTexture(rTexID))
|
|
glDeleteTextures(1,&rTexID);
|
|
rTexMinX = rTexMinY = rTexMaxX = rTexMaxY = 0.0f;
|
|
rTexID = 0;
|
|
rWidth = rHeight = 0;
|
|
FreeImage(rImage);
|
|
}
|
|
|
|
void ZImage::SetAlpha(Uint8 alpha)
|
|
{
|
|
rAlpha = alpha;
|
|
}
|
|
|
|
void ZImage::SetColorKey(Uint8 red, Uint8 green, Uint8 blue)
|
|
{
|
|
Uint32 color = SDL_MapRGB(rImage->format,red,green,blue);
|
|
|
|
if(rImage)
|
|
{
|
|
if(SDL_SetColorKey(rImage, SDL_SRCCOLORKEY, color) < 0)
|
|
rEngine->ReportError(ZERR_SDL_INTERNAL,FormatStr("SDL_SetColorKey failed in ZImage::SetColorKey: %s",SDL_GetError()));
|
|
else
|
|
Reload(); //do the reattach hack, this gets a new OpenGL surface for the same image
|
|
}
|
|
else
|
|
rEngine->ReportError(ZERR_NOIMAGE,"SetColorKey");
|
|
}
|
|
|
|
void ZImage::Draw(int x, int y) const
|
|
{
|
|
Draw(static_cast<float>(x),static_cast<float>(y));
|
|
}
|
|
|
|
void ZImage::DrawClipped(int x, int y, ZRect clipRect) const
|
|
{
|
|
DrawClipped(static_cast<float>(x),static_cast<float>(y),clipRect);
|
|
}
|
|
|
|
void ZImage::Draw(float x, float y) const
|
|
{
|
|
glColor4ub(255,255,255,rAlpha); //sets the color correctly
|
|
Bind();
|
|
glBegin(GL_TRIANGLE_STRIP); //triangle strips, speedier?
|
|
glTexCoord2f(rTexMinX,rTexMinY); glVertex2f(x,y);
|
|
glTexCoord2f(rTexMaxX,rTexMinY); glVertex2f(x+rWidth,y);
|
|
glTexCoord2f(rTexMinX,rTexMaxY); glVertex2f(x,y+rHeight);
|
|
glTexCoord2f(rTexMaxX,rTexMaxY); glVertex2f(x+rWidth,y+rHeight);
|
|
glEnd();
|
|
glColor4ub(255,255,255,255); //be responsible, return to standard color state
|
|
}
|
|
|
|
void ZImage::Draw(float x, float y, Uint8 vc[]) const
|
|
{
|
|
Bind();
|
|
glBegin(GL_TRIANGLE_STRIP); //triangle strips, speedier?
|
|
glTexCoord2f(rTexMinX,rTexMinY); glColor4ub(vc[0],vc[1],vc[2],vc[3]); glVertex2f(x,y);
|
|
glTexCoord2f(rTexMaxX,rTexMinY); glColor4ub(vc[4],vc[5],vc[6],vc[7]); glVertex2f(x+rWidth,y);
|
|
glTexCoord2f(rTexMinX,rTexMaxY); glColor4ub(vc[12],vc[13],vc[14],vc[15]); glVertex2f(x,y+rHeight); //12-15 here to keep counterclockwise
|
|
glTexCoord2f(rTexMaxX,rTexMaxY); glColor4ub(vc[8],vc[9],vc[10],vc[11]); glVertex2f(x+rWidth,y+rHeight);
|
|
glEnd();
|
|
glColor4ub(255,255,255,255); //be responsible, return to standard color state
|
|
}
|
|
|
|
void ZImage::DrawRotated(int x, int y, float angle) const
|
|
{
|
|
DrawRotated(static_cast<float>(x),static_cast<float>(y),angle);
|
|
}
|
|
|
|
void ZImage::DrawRotated(float x, float y, float angle) const
|
|
{
|
|
//center point
|
|
float cX,cY;
|
|
cX = rWidth/2.0f;
|
|
cY = rHeight/2.0f;
|
|
|
|
glPushMatrix();
|
|
glTranslatef(x+cX,y+cY,0); //translate to center
|
|
glRotatef(angle,0,0,1.0f); //rotate on z axis, to keep x&y parallel to 2D plane
|
|
glColor4ub(255,255,255,rAlpha);
|
|
Bind();
|
|
//draw is modified to be based around center//
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
glTexCoord2f(rTexMinX,rTexMinY); glVertex2f(-cX,-cY);
|
|
glTexCoord2f(rTexMaxX,rTexMinY); glVertex2f(-cX+rWidth,-cY);
|
|
glTexCoord2f(rTexMinX,rTexMaxY); glVertex2f(-cX,-cY+rHeight);
|
|
glTexCoord2f(rTexMaxX,rTexMaxY); glVertex2f(-cX+rWidth,-cY+rHeight);
|
|
glEnd();
|
|
glPopMatrix();
|
|
}
|
|
|
|
void ZImage::DrawRotated(float x, float y, float angle, Uint8 vc[]) const
|
|
{
|
|
//center point
|
|
float cX,cY;
|
|
cX = rWidth/2.0f;
|
|
cY = rHeight/2.0f;
|
|
|
|
glPushMatrix();
|
|
glTranslatef(x+cX,y+cY,0); //translate to center
|
|
glRotatef(angle,0,0,1.0f); //rotate on z axis, to keep x&y parallel to 2D plane
|
|
Bind();
|
|
//draw is modified to be based around center//
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
glTexCoord2f(rTexMinX,rTexMinY); glColor4ub(vc[0],vc[1],vc[2],vc[3]); glVertex2f(-cX,-cY);
|
|
glTexCoord2f(rTexMaxX,rTexMinY); glColor4ub(vc[4],vc[6],vc[6],vc[7]); glVertex2f(-cX+rWidth,-cY);
|
|
glTexCoord2f(rTexMinX,rTexMaxY); glColor4ub(vc[12],vc[13],vc[14],vc[15]); glVertex2f(-cX,-cY+rHeight);
|
|
glTexCoord2f(rTexMaxX,rTexMaxY); glColor4ub(vc[8],vc[9],vc[10],vc[11]); glVertex2f(-cX+rWidth,-cY+rHeight);
|
|
glEnd();
|
|
glPopMatrix();
|
|
}
|
|
|
|
void ZImage::DrawClipped(float x, float y, ZRect clipRect) const
|
|
{
|
|
ZRect imgRect(x,y,rWidth,rHeight);
|
|
|
|
if(clipRect.Contains(imgRect))
|
|
{
|
|
Draw(x,y);
|
|
}
|
|
else if(clipRect.Intersects(imgRect))
|
|
{
|
|
//This is some pretty complex code, it is broken down in 4 steps.
|
|
|
|
//Step 1: The intersection rectangle (inRect) is compared to the image rectangle and the overlapping area is found.
|
|
ZRect inRect = clipRect.Intersection(imgRect);
|
|
|
|
//Step 2: The portion of the image that needs to be drawn is being mapped to triangle strips the same size as the intersection
|
|
// of the clipping and image rectangles and then transformed to texture coordinates via xScale and yScale.
|
|
// (double is used for needed precision when dealing with the scaling)
|
|
double xScale = (rTexMaxX - rTexMinX)*rWidth; //texCoordWidth/imgWidth
|
|
double yScale = (rTexMaxY - rTexMinY)*rHeight; //texCoordHeight/imgHeight
|
|
double nx = rTexMinX + (inRect.X()-x)/xScale; //cut off left side
|
|
double ny = rTexMinY + (inRect.Y()-y)/yScale; //cut off top
|
|
double nw = nx + inRect.Width()/xScale; //cut off right side
|
|
double nh = ny + inRect.Height()/yScale; //cut off bottom
|
|
|
|
glColor4ub(255,255,255,rAlpha);
|
|
Bind();
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
//Step 3: The texture coords are modified to only specify the portion of the texture which falls within the clipping rect.
|
|
//Step 4: The vertices are changed to the sides of the clipping rectangle in glVertex2f.
|
|
glTexCoord2d(nx,ny); glVertex2f(inRect.Left(),inRect.Top());
|
|
glTexCoord2d(nw,ny); glVertex2f(inRect.Right(),inRect.Top());
|
|
glTexCoord2d(nx,nh); glVertex2f(inRect.Left(),inRect.Bottom());
|
|
glTexCoord2d(nw,nh); glVertex2f(inRect.Right(),inRect.Bottom());
|
|
glEnd();
|
|
glColor4ub(255,255,255,255); //be responsible, return to standard color state
|
|
}
|
|
else //doesn't contain nor intersect
|
|
{
|
|
//draw nothing
|
|
}
|
|
}
|
|
|
|
void ZImage::DrawClipped(float x, float y, ZRect clipRect, Uint8 vc[]) const
|
|
{
|
|
ZRect imgRect(x,y,rWidth,rHeight);
|
|
|
|
if(clipRect.Contains(imgRect))
|
|
{
|
|
Draw(x,y);
|
|
}
|
|
else if(clipRect.Intersects(imgRect))
|
|
{
|
|
//This is some pretty complex code, it is broken down in 4 steps.
|
|
|
|
//Step 1: The intersection rectangle (inRect) is compared to the image rectangle and the overlapping area is found.
|
|
ZRect inRect = clipRect.Intersection(imgRect);
|
|
|
|
//Step 2: The portion of the image that needs to be drawn is being mapped to triangle strips the same size as the intersection
|
|
// of the clipping and image rectangles and then transformed to texture coordinates via xScale and yScale.
|
|
// (double is used for needed precision when dealing with the scaling)
|
|
double xScale = (rTexMaxX - rTexMinX)*rWidth; //texCoordWidth/imgWidth
|
|
double yScale = (rTexMaxY - rTexMinY)*rHeight; //texCoordHeight/imgHeight
|
|
double nx = rTexMinX + (inRect.X()-x)/xScale; //cut off left side
|
|
double ny = rTexMinY + (inRect.Y()-y)/yScale; //cut off top
|
|
double nw = nx + inRect.Width()/xScale; //cut off right side
|
|
double nh = ny + inRect.Height()/yScale; //cut off bottom
|
|
|
|
Bind();
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
//Step 3: The texture coords are modified to only specify the portion of the texture which falls within the clipping rect.
|
|
//Step 4: The vertices are changed to the sides of the clipping rectangle in glVertex2f.
|
|
glTexCoord2d(nx,ny); glColor4ub(vc[0],vc[1],vc[2],vc[3]); glVertex2f(inRect.Left(),inRect.Top());
|
|
glTexCoord2d(nw,ny); glColor4ub(vc[4],vc[5],vc[6],vc[7]); glVertex2f(inRect.Right(),inRect.Top());
|
|
glTexCoord2d(nx,nh); glColor4ub(vc[12],vc[13],vc[14],vc[15]); glVertex2f(inRect.Left(),inRect.Bottom());
|
|
glTexCoord2d(nw,nh); glColor4ub(vc[8],vc[9],vc[10],vc[11]); glVertex2f(inRect.Right(),inRect.Bottom());
|
|
glEnd();
|
|
glColor4ub(255,255,255,255); //be responsible, return to standard color state
|
|
}
|
|
else //doesn't contain nor intersect
|
|
{
|
|
//draw nothing
|
|
}
|
|
}
|
|
|
|
void ZImage::Flip(bool horizontal, bool vertical)
|
|
{
|
|
//all that a flip does is invert the Min/Max coordinates
|
|
if(horizontal)
|
|
std::swap(rTexMinX,rTexMaxX);
|
|
if(vertical)
|
|
std::swap(rTexMinY,rTexMaxY);
|
|
}
|
|
|
|
//stretching and resizing is very inexpensive, done via variables
|
|
void ZImage::Stretch(float xFactor, float yFactor)
|
|
{
|
|
rWidth = xFactor*rWidth;
|
|
rHeight = yFactor*rHeight;
|
|
}
|
|
|
|
void ZImage::Resize(float width, float height)
|
|
{
|
|
rWidth = width;
|
|
rHeight = height;
|
|
}
|
|
|
|
//this is available for other uses of ZEngine
|
|
void ZImage::Bind() const
|
|
{
|
|
if(rTexID)
|
|
glBindTexture(GL_TEXTURE_2D, rTexID);
|
|
else
|
|
rEngine->ReportError(ZERR_NOIMAGE,"Bind");
|
|
|
|
}
|
|
|
|
bool ZImage::IsLoaded() const
|
|
{
|
|
return glIsTexture(rTexID) == GL_TRUE;
|
|
}
|
|
|
|
#elif (GFX_BACKEND == ZE_SDL)
|
|
|
|
void ZImage::Attach(SDL_Surface *surface)
|
|
{
|
|
Release();
|
|
|
|
//surface conversion//
|
|
SDL_Surface *temp = surface;
|
|
surface = SDL_DisplayFormatAlpha(temp); //TTF_RenderTextBlended relys on this
|
|
if(surface)
|
|
{
|
|
FreeImage(temp);
|
|
}
|
|
else //can't convert
|
|
{
|
|
rEngine->ReportError(ZERR_SDL_INTERNAL,FormatStr("SDL_DisplayFormatAlpha failed in ZImage::Attach: %s",SDL_GetError()));
|
|
surface = temp;
|
|
}
|
|
|
|
if(surface)
|
|
rImage = surface;
|
|
else
|
|
rEngine->ReportError(ZERR_NOIMAGE,"Attach");
|
|
}
|
|
|
|
void ZImage::Reload()
|
|
{
|
|
//currently a no-op
|
|
}
|
|
|
|
void ZImage::Release()
|
|
{
|
|
FreeImage(rImage);
|
|
}
|
|
|
|
void ZImage::SetAlpha(Uint8 alpha)
|
|
{
|
|
rAlpha = alpha;
|
|
if(rImage)
|
|
{
|
|
if(SDL_SetAlpha(rImage, SDL_SRCALPHA, alpha) < 0)
|
|
rEngine->ReportError(ZERR_SDL_INTERNAL,FormatStr("SDL_SetAlpha failed in ZImage::SetAlpha: %s",SDL_GetError()));
|
|
}
|
|
else
|
|
rEngine->ReportError(ZERR_NOIMAGE,"SetAlpha");
|
|
}
|
|
|
|
void ZImage::SetColorKey(Uint8 red, Uint8 green, Uint8 blue)
|
|
{
|
|
Uint32 color = SDL_MapRGBA(rImage->format,red,green,blue,255);
|
|
|
|
if(rImage)
|
|
{
|
|
if(SDL_SetColorKey(rImage, SDL_RLEACCEL|SDL_SRCCOLORKEY, color) < 0)
|
|
rEngine->ReportError(ZERR_SDL_INTERNAL,FormatStr("SDL_SetColorKey failed in ZImage::SetColorKey: %s",SDL_GetError()));
|
|
//surface conversion//
|
|
SDL_Surface *temp = rImage;
|
|
rImage = SDL_DisplayFormatAlpha(temp); //TTF_RenderTextBlended relys on this
|
|
if(rImage)
|
|
{
|
|
FreeImage(temp);
|
|
}
|
|
else //can't convert
|
|
{
|
|
rEngine->ReportError(ZERR_SDL_INTERNAL,FormatStr("SDL_DisplayFormatAlpha failed in ZImage::SetColorKey: %s",SDL_GetError()));
|
|
rImage = temp;
|
|
}
|
|
}
|
|
else
|
|
rEngine->ReportError(ZERR_NOIMAGE,"SetColorKey");
|
|
}
|
|
|
|
void ZImage::Draw(int x, int y) const
|
|
{
|
|
SDL_Rect rect;
|
|
rect.x = static_cast<Sint16>(x);
|
|
rect.y = static_cast<Sint16>(y);
|
|
SDL_BlitSurface(rImage, NULL, rEngine->Display(), &rect);
|
|
}
|
|
|
|
void ZImage::DrawClipped(int x, int y, ZRect clipRect) const
|
|
{
|
|
ZRect img(static_cast<Sint16>(x),static_cast<Sint16>(y),static_cast<Sint16>(rImage->w),static_cast<Sint16>(rImage->h));
|
|
SDL_Rect inRect,imgRect;
|
|
|
|
|
|
imgRect = inRect = clipRect.Intersection(img).SDLrect();
|
|
inRect.x -= x;
|
|
inRect.y -= y;
|
|
|
|
SDL_BlitSurface(rImage, &inRect, rEngine->Display(), &imgRect);
|
|
//SDL_FillRect(rEngine->Display(), &inRect, SDL_MapRGB(rEngine->Display()->format,0,255,0));
|
|
}
|
|
|
|
bool ZImage::IsLoaded() const
|
|
{
|
|
return rImage ? true : false;
|
|
}
|
|
|
|
#endif //GFX_BACKEND
|
|
|
|
SDL_Surface* ZImage::Surface() const
|
|
{
|
|
return rImage;
|
|
}
|
|
|
|
#if (GFX_BACKEND == ZE_OGL)
|
|
|
|
float ZImage::Width() const
|
|
{
|
|
return rWidth;
|
|
}
|
|
|
|
float ZImage::Height() const
|
|
{
|
|
return rHeight;
|
|
}
|
|
|
|
#elif (GFX_BACKEND == ZE_SDL)
|
|
|
|
int ZImage::Width() const
|
|
{
|
|
return rImage->w;
|
|
}
|
|
|
|
int ZImage::Height() const
|
|
{
|
|
return rImage->h;
|
|
}
|
|
|
|
#endif //GFX_BACKEND
|
|
|
|
Uint8 ZImage::Alpha() const
|
|
{
|
|
return rAlpha;
|
|
}
|
|
|
|
}
|