summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/CMakeLists.txt2
-rw-r--r--src/Makefile.am2
-rw-r--r--src/compoundsprite.cpp8
-rw-r--r--src/graphics.cpp737
-rw-r--r--src/graphics.h96
-rw-r--r--src/graphicsmanager.cpp5
-rw-r--r--src/maplayer.cpp2
-rw-r--r--src/mobileopenglgraphics.h2
-rw-r--r--src/normalopenglgraphics.h2
-rw-r--r--src/nullopenglgraphics.h2
-rw-r--r--src/resources/atlasmanager.cpp4
-rw-r--r--src/resources/image.h1
-rw-r--r--src/safeopenglgraphics.cpp25
-rw-r--r--src/safeopenglgraphics.h17
-rw-r--r--src/sdlgraphics.cpp773
-rw-r--r--src/sdlgraphics.h140
16 files changed, 1014 insertions, 804 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6f2638ebb..a46683928 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -688,6 +688,8 @@ SET(SRCS
rotationalparticle.h
safeopenglgraphics.cpp
safeopenglgraphics.h
+ sdlgraphics.cpp
+ sdlgraphics.h
shopitem.cpp
shopitem.h
simpleanimation.cpp
diff --git a/src/Makefile.am b/src/Makefile.am
index 27069e927..a3b551313 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -689,6 +689,8 @@ manaplus_SOURCES += gui/widgets/avatarlistbox.cpp \
rotationalparticle.h \
safeopenglgraphics.cpp\
safeopenglgraphics.h \
+ sdlgraphics.cpp \
+ sdlgraphics.h \
shopitem.cpp \
shopitem.h \
simpleanimation.cpp \
diff --git a/src/compoundsprite.cpp b/src/compoundsprite.cpp
index 748bf4d42..0d649e48e 100644
--- a/src/compoundsprite.cpp
+++ b/src/compoundsprite.cpp
@@ -21,16 +21,16 @@
#include "compoundsprite.h"
+#include "client.h"
#include "configuration.h"
#include "game.h"
-#include "graphics.h"
#ifdef USE_OPENGL
#include "main.h"
#endif
-#include "client.h"
#include "map.h"
+#include "sdlgraphics.h"
#include "resources/image.h"
#include "resources/imagehelper.h"
@@ -330,8 +330,8 @@ void CompoundSprite::redraw() const
if (!surface)
return;
- Graphics *graphics = new Graphics();
- graphics->setBlitMode(Graphics::BLIT_GFX);
+ SDLGraphics *graphics = new SDLGraphics();
+ graphics->setBlitMode(SDLGraphics::BLIT_GFX);
graphics->setTarget(surface);
graphics->_beginDraw();
diff --git a/src/graphics.cpp b/src/graphics.cpp
index a14d630bf..f32d35f3e 100644
--- a/src/graphics.cpp
+++ b/src/graphics.cpp
@@ -50,12 +50,6 @@
#endif
#endif
-#if SDL_BYTEORDER == SDL_LIL_ENDIAN
-static unsigned int *cR = nullptr;
-static unsigned int *cG = nullptr;
-static unsigned int *cB = nullptr;
-#endif
-
int MSDL_gfxBlitRGBA(SDL_Surface *src, SDL_Rect *srcrect,
SDL_Surface *dst, SDL_Rect *dstrect)
{
@@ -69,7 +63,6 @@ Graphics::Graphics() :
mBpp(0),
mFullscreen(false),
mHWAccel(false),
- mBlitMode(BLIT_NORMAL),
mRedraw(false),
mDoubleBuffer(false),
mRect(),
@@ -77,8 +70,6 @@ Graphics::Graphics() :
mOpenGL(0),
mEnableResize(false),
mNoFrame(false),
- mOldPixel(0),
- mOldAlpha(0),
mName("Software"),
mStartFreeMem(0),
mSync(false),
@@ -375,185 +366,6 @@ bool Graphics::drawImage(const Image *image, int x, int y)
}
}
-bool Graphics::drawRescaledImage(const Image *const image, int srcX, int srcY,
- int dstX, int dstY,
- const int width, const int height,
- const int desiredWidth,
- const int desiredHeight,
- const bool useColor A_UNUSED)
-{
- FUNC_BLOCK("Graphics::drawRescaledImage", 1)
- // Check that preconditions for blitting are met.
- if (!mTarget || !image)
- return false;
- if (!image->mSDLSurface)
- return false;
-
- Image *const tmpImage = image->SDLgetScaledImage(
- desiredWidth, desiredHeight);
-
- if (!tmpImage)
- return false;
- if (!tmpImage->mSDLSurface)
- return false;
-
- dstX += mClipStack.top().xOffset;
- dstY += mClipStack.top().yOffset;
-
- srcX += image->mBounds.x;
- srcY += image->mBounds.y;
-
- SDL_Rect dstRect;
- SDL_Rect srcRect;
- dstRect.x = static_cast<int16_t>(dstX);
- dstRect.y = static_cast<int16_t>(dstY);
- srcRect.x = static_cast<int16_t>(srcX);
- srcRect.y = static_cast<int16_t>(srcY);
- srcRect.w = static_cast<uint16_t>(width);
- srcRect.h = static_cast<uint16_t>(height);
-
- const bool returnValue = !(SDL_BlitSurface(tmpImage->mSDLSurface,
- &srcRect, mTarget, &dstRect) < 0);
-
- delete tmpImage;
-
- return returnValue;
-}
-
-bool Graphics::drawImage2(const Image *const image, int srcX, int srcY,
- int dstX, int dstY, const int width,
- const int height, const bool useColor A_UNUSED)
-{
- FUNC_BLOCK("Graphics::drawImage2", 1)
- // Check that preconditions for blitting are met.
- if (!mTarget || !image || !image->mSDLSurface)
- return false;
-
- dstX += mClipStack.top().xOffset;
- dstY += mClipStack.top().yOffset;
-
- srcX += image->mBounds.x;
- srcY += image->mBounds.y;
-
- SDL_Rect dstRect;
- SDL_Rect srcRect;
- dstRect.x = static_cast<int16_t>(dstX);
- dstRect.y = static_cast<int16_t>(dstY);
- srcRect.x = static_cast<int16_t>(srcX);
- srcRect.y = static_cast<int16_t>(srcY);
- srcRect.w = static_cast<uint16_t>(width);
- srcRect.h = static_cast<uint16_t>(height);
-
- if (mBlitMode == BLIT_NORMAL)
- {
- return !(SDL_BlitSurface(image->mSDLSurface, &srcRect,
- mTarget, &dstRect) < 0);
- }
- else
- {
- return !(SDL_gfxBlitRGBA(image->mSDLSurface, &srcRect,
- mTarget, &dstRect) < 0);
- }
-}
-
-void Graphics::drawImagePattern(const Image *const image,
- const int x, const int y,
- const int w, const int h)
-{
- FUNC_BLOCK("Graphics::drawImagePattern", 1)
- // Check that preconditions for blitting are met.
- if (!mTarget || !image)
- return;
- if (!image->mSDLSurface)
- return;
-
- const int iw = image->mBounds.w;
- const int ih = image->mBounds.h;
-
- if (iw == 0 || ih == 0)
- return;
-
- for (int py = 0; py < h; py += ih) // Y position on pattern plane
- {
- const int dh = (py + ih >= h) ? h - py : ih;
- const int srcY = image->mBounds.y;
- const int dstY = y + py + mClipStack.top().yOffset;
-
- for (int px = 0; px < w; px += iw) // X position on pattern plane
- {
- const int dw = (px + iw >= w) ? w - px : iw;
- const int srcX = image->mBounds.x;
- const int dstX = x + px + mClipStack.top().xOffset;
-
- SDL_Rect dstRect;
- SDL_Rect srcRect;
- dstRect.x = static_cast<int16_t>(dstX);
- dstRect.y = static_cast<int16_t>(dstY);
- srcRect.x = static_cast<int16_t>(srcX);
- srcRect.y = static_cast<int16_t>(srcY);
- srcRect.w = static_cast<uint16_t>(dw);
- srcRect.h = static_cast<uint16_t>(dh);
-
- SDL_BlitSurface(image->mSDLSurface, &srcRect, mTarget, &dstRect);
- }
- }
-}
-
-void Graphics::drawRescaledImagePattern(const Image *const image,
- const int x, const int y,
- const int w, const int h,
- const int scaledWidth,
- const int scaledHeight)
-{
- // Check that preconditions for blitting are met.
- if (!mTarget || !image)
- return;
- if (!image->mSDLSurface)
- return;
-
- if (scaledHeight == 0 || scaledWidth == 0)
- return;
-
- Image *const tmpImage = image->SDLgetScaledImage(
- scaledWidth, scaledHeight);
- if (!tmpImage)
- return;
-
- const int iw = tmpImage->mBounds.w;
- const int ih = tmpImage->mBounds.h;
-
- if (iw == 0 || ih == 0)
- return;
-
- for (int py = 0; py < h; py += ih) // Y position on pattern plane
- {
- const int dh = (py + ih >= h) ? h - py : ih;
- const int srcY = tmpImage->mBounds.y;
- const int dstY = y + py + mClipStack.top().yOffset;
-
- for (int px = 0; px < w; px += iw) // X position on pattern plane
- {
- const int dw = (px + iw >= w) ? w - px : iw;
- const int srcX = tmpImage->mBounds.x;
- const int dstX = x + px + mClipStack.top().xOffset;
-
- SDL_Rect dstRect;
- SDL_Rect srcRect;
- dstRect.x = static_cast<int16_t>(dstX);
- dstRect.y = static_cast<int16_t>(dstY);
- srcRect.x = static_cast<int16_t>(srcX);
- srcRect.y = static_cast<int16_t>(srcY);
- srcRect.w = static_cast<uint16_t>(dw);
- srcRect.h = static_cast<uint16_t>(dh);
-
- SDL_BlitSurface(tmpImage->mSDLSurface, &srcRect,
- mTarget, &dstRect);
- }
- }
-
- delete tmpImage;
-}
-
void Graphics::drawImageRect(const int x, const int y,
const int w, const int h,
const Image *const topLeft,
@@ -614,6 +426,18 @@ void Graphics::drawImageRect(int x, int y, int w, int h,
imgRect.grid[4]);
}
+bool Graphics::drawNet(const int x1, const int y1, const int x2, const int y2,
+ const int width, const int height)
+{
+ for (int y = y1; y < y2; y += height)
+ drawLine(x1, y, x2, y);
+
+ for (int x = x1; x < x2; x += width)
+ drawLine(x, y1, x, y2);
+
+ return true;
+}
+
bool Graphics::calcImageRect(ImageVertexes *const vert,
const int x, const int y,
const int w, const int h,
@@ -673,540 +497,3 @@ bool Graphics::calcImageRect(ImageVertexes *const vert,
BLOCK_END("Graphics::calcImageRect")
return 0;
}
-
-void Graphics::calcImagePattern(ImageVertexes* const vert,
- const Image *const image,
- const int x, const int y,
- const int w, const int h) const
-{
- // Check that preconditions for blitting are met.
- if (!vert || !mTarget || !image || !image->mSDLSurface)
- return;
-
- const int iw = image->mBounds.w;
- const int ih = image->mBounds.h;
-
- if (iw == 0 || ih == 0)
- return;
-
- for (int py = 0; py < h; py += ih) // Y position on pattern plane
- {
- const int dh = (py + ih >= h) ? h - py : ih;
- const int srcY = image->mBounds.y;
- const int dstY = y + py + mClipStack.top().yOffset;
-
- for (int px = 0; px < w; px += iw) // X position on pattern plane
- {
- const int dw = (px + iw >= w) ? w - px : iw;
- const int srcX = image->mBounds.x;
- const int dstX = x + px + mClipStack.top().xOffset;
-
- DoubleRect *const r = new DoubleRect();
- SDL_Rect &dstRect = r->dst;
- SDL_Rect &srcRect = r->src;
- dstRect.x = static_cast<int16_t>(dstX);
- dstRect.y = static_cast<int16_t>(dstY);
- srcRect.x = static_cast<int16_t>(srcX);
- srcRect.y = static_cast<int16_t>(srcY);
- srcRect.w = static_cast<uint16_t>(dw);
- srcRect.h = static_cast<uint16_t>(dh);
-
- if (SDL_FakeUpperBlit(image->mSDLSurface, &srcRect,
- mTarget, &dstRect) == 1)
- {
- vert->sdl.push_back(r);
- }
- else
- {
- delete r;
- }
- }
- }
-}
-
-void Graphics::calcImagePattern(ImageCollection* const vertCol,
- const Image *const image,
- const int x, const int y,
- const int w, const int h) const
-{
- ImageVertexes *vert = nullptr;
- if (vertCol->currentImage != image)
- {
- vert = new ImageVertexes();
- vertCol->currentImage = image;
- vertCol->currentVert = vert;
- vert->image = image;
- vertCol->draws.push_back(vert);
- }
- else
- {
- vert = vertCol->currentVert;
- }
-
- calcImagePattern(vert, image, x, y, w, h);
-}
-
-void Graphics::calcTile(ImageVertexes *const vert,
- const Image *const image,
- int x, int y) const
-{
- vert->image = image;
- calcTile(vert, x, y);
-}
-
-void Graphics::calcTile(ImageCollection *const vertCol,
- const Image *const image,
- int x, int y)
-{
- if (vertCol->currentImage != image)
- {
- ImageVertexes *const vert = new ImageVertexes();
- vertCol->currentImage = image;
- vertCol->currentVert = vert;
- vert->image = image;
- vertCol->draws.push_back(vert);
- calcTile(vert, x, y);
- }
- else
- {
- calcTile(vertCol->currentVert, x, y);
- }
-}
-
-void Graphics::drawTile(const ImageCollection *const vertCol)
-{
- const ImageVertexesVector &draws = vertCol->draws;
- const ImageCollectionCIter it_end = draws.end();
- for (ImageCollectionCIter it = draws.begin(); it != it_end; ++ it)
- {
- const ImageVertexes *const vert = *it;
- const Image *const img = vert->image;
- const DoubleRects *const rects = &vert->sdl;
- DoubleRects::const_iterator it2 = rects->begin();
- const DoubleRects::const_iterator it2_end = rects->end();
- while (it2 != it2_end)
- {
- SDL_LowerBlit(img->mSDLSurface, &(*it2)->src,
- mTarget, &(*it2)->dst);
- ++ it2;
- }
- }
-}
-
-void Graphics::calcTile(ImageVertexes *const vert, int x, int y) const
-{
- // Check that preconditions for blitting are met.
- if (!vert || !vert->image || !vert->image->mSDLSurface)
- return;
-
- const Image *const image = vert->image;
-
- x += mClipStack.top().xOffset;
- y += mClipStack.top().yOffset;
-
- DoubleRect *rect = new DoubleRect();
-
- rect->dst.x = static_cast<int16_t>(x);
- rect->dst.y = static_cast<int16_t>(y);
- rect->src.x = static_cast<int16_t>(image->mBounds.x);
- rect->src.y = static_cast<int16_t>(image->mBounds.y);
- rect->src.w = static_cast<uint16_t>(image->mBounds.w);
- rect->src.h = static_cast<uint16_t>(image->mBounds.h);
- if (SDL_FakeUpperBlit(image->mSDLSurface, &rect->src,
- mTarget, &rect->dst) == 1)
- {
- vert->sdl.push_back(rect);
- }
- else
- {
- delete rect;
- }
-}
-
-void Graphics::drawTile(const ImageVertexes *const vert)
-{
- // vert and img must be != 0
- const Image *const img = vert->image;
- const DoubleRects *const rects = &vert->sdl;
- DoubleRects::const_iterator it = rects->begin();
- const DoubleRects::const_iterator it_end = rects->end();
- while (it != it_end)
- {
- SDL_LowerBlit(img->mSDLSurface, &(*it)->src, mTarget, &(*it)->dst);
- ++ it;
- }
-}
-
-void Graphics::updateScreen()
-{
- BLOCK_START("Graphics::updateScreen")
- if (mDoubleBuffer)
- {
- SDL_Flip(mTarget);
- }
- else
- {
- SDL_UpdateRects(mTarget, 1, &mRect);
-// SDL_UpdateRect(mTarget, 0, 0, 0, 0);
- }
- BLOCK_END("Graphics::updateScreen")
-}
-
-SDL_Surface *Graphics::getScreenshot()
-{
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
- const int rmask = 0xff000000;
- const int gmask = 0x00ff0000;
- const int bmask = 0x0000ff00;
-#else
- const int rmask = 0x000000ff;
- const int gmask = 0x0000ff00;
- const int bmask = 0x00ff0000;
-#endif
- const int amask = 0x00000000;
-
- SDL_Surface *const screenshot = SDL_CreateRGBSurface(SDL_SWSURFACE,
- mTarget->w, mTarget->h, 24, rmask, gmask, bmask, amask);
-
- if (screenshot)
- SDL_BlitSurface(mTarget, nullptr, screenshot, nullptr);
-
- return screenshot;
-}
-
-bool Graphics::drawNet(const int x1, const int y1, const int x2, const int y2,
- const int width, const int height)
-{
- for (int y = y1; y < y2; y += height)
- drawLine(x1, y, x2, y);
-
- for (int x = x1; x < x2; x += width)
- drawLine(x, y1, x, y2);
-
- return true;
-}
-
-bool Graphics::calcWindow(ImageCollection *const vertCol,
- const int x, const int y, const int w, const int h,
- const ImageRect &imgRect)
-{
- ImageVertexes *vert = nullptr;
- Image *const image = imgRect.grid[4];
- if (vertCol->currentImage != image)
- {
- vert = new ImageVertexes();
- vertCol->currentImage = image;
- vertCol->currentVert = vert;
- vert->image = image;
- vertCol->draws.push_back(vert);
-// calcTile(vert, x, y);
- }
- else
- {
- vert = vertCol->currentVert;
- }
-
- return calcImageRect(vert, x, y, w, h,
- imgRect.grid[0], imgRect.grid[2], imgRect.grid[6], imgRect.grid[8],
- imgRect.grid[1], imgRect.grid[5], imgRect.grid[7], imgRect.grid[3],
- imgRect.grid[4]);
-}
-
-int Graphics::SDL_FakeUpperBlit(const SDL_Surface *const src,
- SDL_Rect *const srcrect,
- const SDL_Surface *const dst,
- SDL_Rect *dstrect) const
-{
- SDL_Rect fulldst;
- int srcx, srcy, w, h;
-
- /* Make sure the surfaces aren't locked */
- if (!src || !dst)
- return -1;
-
- if (src->locked || dst->locked)
- return -1;
-
- /* If the destination rectangle is nullptr, use the entire dest surface */
- if (!dstrect)
- {
- fulldst.x = 0;
- fulldst.y = 0;
- dstrect = &fulldst;
- }
-
- /* clip the source rectangle to the source surface */
- if (srcrect)
- {
- srcx = srcrect->x;
- w = srcrect->w;
- if (srcx < 0)
- {
- w += srcx;
- dstrect->x -= static_cast<int16_t>(srcx);
- srcx = 0;
- }
- int maxw = src->w - srcx;
- if (maxw < w)
- w = maxw;
-
- srcy = srcrect->y;
- h = srcrect->h;
- if (srcy < 0)
- {
- h += srcy;
- dstrect->y -= static_cast<int16_t>(srcy);
- srcy = 0;
- }
- int maxh = src->h - srcy;
- if (maxh < h)
- h = maxh;
- }
- else
- {
- srcx = 0;
- srcy = 0;
- w = src->w;
- h = src->h;
- }
-
- /* clip the destination rectangle against the clip rectangle */
- {
- const SDL_Rect *const clip = &dst->clip_rect;
- int dx = clip->x - dstrect->x;
- if (dx > 0)
- {
- w -= dx;
- dstrect->x += static_cast<int16_t>(dx);
- srcx += dx;
- }
- dx = dstrect->x + w - clip->x - clip->w;
- if (dx > 0)
- w -= dx;
-
- int dy = clip->y - dstrect->y;
- if (dy > 0)
- {
- h -= dy;
- dstrect->y += static_cast<int16_t>(dy);
- srcy += dy;
- }
- dy = dstrect->y + h - clip->y - clip->h;
- if (dy > 0)
- h -= dy;
- }
-
- if (w > 0 && h > 0)
- {
- if (srcrect)
- {
- srcrect->x = static_cast<int16_t>(srcx);
- srcrect->y = static_cast<int16_t>(srcy);
- srcrect->w = static_cast<int16_t>(w);
- srcrect->h = static_cast<int16_t>(h);
- }
- dstrect->w = static_cast<int16_t>(w);
- dstrect->h = static_cast<int16_t>(h);
-
- return 1;
-// return SDL_LowerBlit(src, &sr, dst, dstrect);
- }
- dstrect->w = dstrect->h = 0;
- return 0;
-}
-
-void Graphics::fillRectangle(const gcn::Rectangle& rectangle)
-{
- FUNC_BLOCK("Graphics::fillRectangle", 1)
- if (mClipStack.empty())
- return;
-
- const gcn::ClipRectangle& top = mClipStack.top();
-
- gcn::Rectangle area = rectangle;
- area.x += top.xOffset;
- area.y += top.yOffset;
-
- if (!area.isIntersecting(top))
- return;
-
- if (mAlpha)
- {
- const int x1 = area.x > top.x ? area.x : top.x;
- const int y1 = area.y > top.y ? area.y : top.y;
- const int x2 = area.x + area.width < top.x + top.width ?
- area.x + area.width : top.x + top.width;
- const int y2 = area.y + area.height < top.y + top.height ?
- area.y + area.height : top.y + top.height;
- int x, y;
-
- SDL_LockSurface(mTarget);
-
- const int bpp = mTarget->format->BytesPerPixel;
- const uint32_t pixel = SDL_MapRGB(mTarget->format,
- static_cast<uint8_t>(mColor.r), static_cast<uint8_t>(mColor.g),
- static_cast<uint8_t>(mColor.b));
-
- switch (bpp)
- {
- case 1:
- for (y = y1; y < y2; y++)
- {
- uint8_t *const p = static_cast<uint8_t *>(mTarget->pixels)
- + y * mTarget->pitch;
- for (x = x1; x < x2; x++)
- *(p + x) = static_cast<uint8_t>(pixel);
- }
- break;
- case 2:
- for (y = y1; y < y2; y++)
- {
- uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
- + y * mTarget->pitch;
- for (x = x1; x < x2; x++)
- {
- uint8_t *const p = p0 + x * 2;
- *reinterpret_cast<uint16_t *>(p) = gcn::SDLAlpha16(
- static_cast<uint16_t>(pixel),
- *reinterpret_cast<uint16_t *>(p),
- static_cast<uint8_t>(mColor.a), mTarget->format);
- }
- }
- break;
- case 3:
- {
- const int ca = 255 - mColor.a;
- const int cr = mColor.r * mColor.a;
- const int cg = mColor.g * mColor.a;
- const int cb = mColor.b * mColor.a;
-
- for (y = y1; y < y2; y++)
- {
- uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
- + y * mTarget->pitch;
- for (x = x1; x < x2; x++)
- {
- uint8_t *const p = p0 + x * 3;
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
- p[2] = static_cast<uint8_t>((p[2] * ca + cb) >> 8);
- p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
- p[0] = static_cast<uint8_t>((p[0] * ca + cr) >> 8);
-#else
- p[0] = static_cast<uint8_t>((p[0] * ca + cb) >> 8);
- p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
- p[2] = static_cast<uint8_t>((p[2] * ca + cr) >> 8);
-#endif
- }
- }
- break;
- }
- case 4:
- {
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
- const unsigned pb = (pixel & 0xff) * mColor.a;
- const unsigned pg = (pixel & 0xff00) * mColor.a;
- const unsigned pr = (pixel & 0xff0000) * mColor.a;
- const unsigned a1 = (255 - mColor.a);
-
- for (y = y1; y < y2; y++)
- {
- uint8_t *p0 = static_cast<uint8_t *>(mTarget->pixels)
- + y * mTarget->pitch;
- for (x = x1; x < x2; x++)
- {
- uint8_t *p = p0 + x * 4;
- uint32_t dst = *reinterpret_cast<uint32_t *>(p);
- const unsigned int b = (pb + (dst & 0xff) * a1) >> 8;
- const unsigned int g = (pg + (dst & 0xff00) * a1) >> 8;
- const unsigned int r = (pr
- + (dst & 0xff0000) * a1) >> 8;
-
- *reinterpret_cast<uint32_t *>(p) = ((b & 0xff)
- | (g & 0xff00) | (r & 0xff0000));
- }
- }
-#else
- if (!cR)
- {
- cR = new unsigned int[0x100];
- cG = new unsigned int[0x100];
- cB = new unsigned int[0x100];
- mOldPixel = 0;
- mOldAlpha = mColor.a;
- }
-
- const SDL_PixelFormat * const format = mTarget->format;
- const unsigned rMask = format->Rmask;
- const unsigned gMask = format->Gmask;
- const unsigned bMask = format->Bmask;
-// const unsigned aMask = format->Amask;
- unsigned rShift = rMask / 0xff;
- unsigned gShift = gMask / 0xff;
- unsigned bShift = bMask / 0xff;
- if (!rShift)
- rShift = 1;
- if (!gShift)
- gShift = 1;
- if (!bShift)
- bShift = 1;
- if (pixel != mOldPixel || mColor.a != mOldAlpha)
- {
- const unsigned pb = (pixel & bMask) * mColor.a;
- const unsigned pg = (pixel & gMask) * mColor.a;
- const unsigned pr = (pixel & rMask) * mColor.a;
- const unsigned a0 = (255 - mColor.a);
-
- const unsigned int a1 = a0 * bShift;
- const unsigned int a2 = a0 * gShift;
- const unsigned int a3 = a0 * rShift;
-
- for (int f = 0; f <= 0xff; f ++)
- {
- cB[f] = ((pb + f * a1) >> 8) & bMask;
- cG[f] = ((pg + f * a2) >> 8) & gMask;
- cR[f] = ((pr + f * a3) >> 8) & rMask;
- }
-
- mOldPixel = pixel;
- mOldAlpha = mColor.a;
- }
-
- for (y = y1; y < y2; y++)
- {
- uint32_t *const p0 = reinterpret_cast<uint32_t*>(
- static_cast<uint8_t*>(mTarget->pixels)
- + y * mTarget->pitch);
- for (x = x1; x < x2; x++)
- {
- uint32_t *const p = p0 + x;
- const uint32_t dst = *p;
- *p = cB[dst & bMask / bShift]
- | cG[(dst & gMask) / gShift]
- | cR[(dst & rMask) / rShift];
- }
- }
-#endif
- break;
- }
- default:
- break;
- }
-
- SDL_UnlockSurface(mTarget);
- }
- else
- {
- SDL_Rect rect;
- rect.x = static_cast<int16_t>(area.x);
- rect.y = static_cast<int16_t>(area.y);
- rect.w = static_cast<uint16_t>(area.width);
- rect.h = static_cast<uint16_t>(area.height);
-
- const uint32_t color = SDL_MapRGBA(mTarget->format,
- static_cast<int8_t>(mColor.r),
- static_cast<int8_t>(mColor.g),
- static_cast<int8_t>(mColor.b),
- static_cast<int8_t>(mColor.a));
- SDL_FillRect(mTarget, &rect, color);
- }
-}
diff --git a/src/graphics.h b/src/graphics.h
index f8a124a89..60313fdaf 100644
--- a/src/graphics.h
+++ b/src/graphics.h
@@ -90,12 +90,6 @@ class ImageRect final
class Graphics : public gcn::SDLGraphics
{
public:
- enum BlitMode
- {
- BLIT_NORMAL = 0,
- BLIT_GFX
- };
-
/**
* Constructor.
*/
@@ -145,33 +139,16 @@ class Graphics : public gcn::SDLGraphics
/**
* Draws a resclaled version of the image
*/
- bool drawRescaledImage(const Image *const image,
- const int srcX, const int srcY,
- const int dstX, const int dstY,
- const int width, const int height,
- const int desiredWidth, const int desiredHeight)
- {
- return drawRescaledImage(image, srcX, srcY,
- dstX, dstY,
- width, height,
- desiredWidth, desiredHeight,
- false);
- }
-
- /**
- * Draws a resclaled version of the image
- */
virtual bool drawRescaledImage(const Image *const image, int srcX,
int srcY, int dstX, int dstY,
const int width, const int height,
const int desiredWidth,
const int desiredHeight,
- const bool useColor = false);
-
+ const bool useColor = false) = 0;
virtual void drawImagePattern(const Image *const image,
const int x, const int y,
- const int w, const int h);
+ const int w, const int h) = 0;
/**
* Draw a pattern based on a rescaled version of the given image...
@@ -180,7 +157,7 @@ class Graphics : public gcn::SDLGraphics
const int x, const int y,
const int w, const int h,
const int scaledWidth,
- const int scaledHeight);
+ const int scaledHeight) = 0;
/**
* Draws a rectangle using images. 4 corner images, 4 side images and 1
@@ -204,46 +181,50 @@ class Graphics : public gcn::SDLGraphics
void drawImageRect(int x, int y, int w, int h,
const ImageRect &imgRect);
- virtual bool calcImageRect(ImageVertexes *const vert,
- const int x, const int y,
- const int w, const int h,
- const Image *const topLeft,
- const Image *const topRight,
- const Image *const bottomLeft,
- const Image *const bottomRight,
- const Image *const top,
- const Image *const right,
- const Image *const bottom,
- const Image *const left,
- const Image *const center);
+ bool calcImageRect(ImageVertexes *const vert,
+ const int x, const int y,
+ const int w, const int h,
+ const Image *const topLeft,
+ const Image *const topRight,
+ const Image *const bottomLeft,
+ const Image *const bottomRight,
+ const Image *const top,
+ const Image *const right,
+ const Image *const bottom,
+ const Image *const left,
+ const Image *const center);
virtual void calcImagePattern(ImageVertexes *const vert,
const Image *const image,
const int x, const int y,
- const int w, const int h) const;
+ const int w, const int h) const = 0;
virtual void calcImagePattern(ImageCollection *const vert,
const Image *const image,
const int x, const int y,
- const int w, const int h) const;
+ const int w, const int h) const = 0;
virtual void calcTile(ImageVertexes *const vert,
- const Image *const image, int x, int y) const;
+ const Image *const image,
+ int x, int y) const = 0;
- virtual void calcTile(ImageVertexes *const vert, int x, int y) const;
+ virtual void calcTileSDL(ImageVertexes *const vert A_UNUSED,
+ int x A_UNUSED, int y A_UNUSED) const
+ {
+ }
- virtual void drawTile(const ImageVertexes *const vert);
+ virtual void drawTile(const ImageVertexes *const vert) = 0;
- virtual void drawTile(const ImageCollection *const vertCol);
+ virtual void drawTile(const ImageCollection *const vertCol) = 0;
virtual void calcTile(ImageCollection *const vertCol,
const Image *const image,
- int x, int y);
+ int x, int y) = 0;
virtual bool calcWindow(ImageCollection *const vertCol,
const int x, const int y,
const int w, const int h,
- const ImageRect &imgRect);
+ const ImageRect &imgRect) = 0;
/**
* Draws a rectangle using images. 4 corner images, 4 side images and 1
@@ -253,19 +234,14 @@ class Graphics : public gcn::SDLGraphics
const ImageRect &imgRect)
{ drawImageRect(area.x, area.y, area.width, area.height, imgRect); }
- void setBlitMode(const BlitMode mode)
- { mBlitMode = mode; }
-
- BlitMode getBlitMode() const A_WARN_UNUSED
- { return mBlitMode; }
-
- void fillRectangle(const gcn::Rectangle& rectangle) override;
+ virtual void fillRectangle(const gcn::Rectangle& rectangle)
+ override = 0;
/**
* Updates the screen. This is done by either copying the buffer to the
* screen or swapping pages.
*/
- virtual void updateScreen();
+ virtual void updateScreen() = 0;
/**
* Returns the width of the screen.
@@ -280,7 +256,7 @@ class Graphics : public gcn::SDLGraphics
/**
* Takes a screenshot and returns it as SDL surface.
*/
- virtual SDL_Surface *getScreenshot() A_WARN_UNUSED;
+ virtual SDL_Surface *getScreenshot() A_WARN_UNUSED = 0;
virtual void prepareScreenshot()
{ }
@@ -375,7 +351,7 @@ class Graphics : public gcn::SDLGraphics
int srcX, int srcY,
int dstX, int dstY,
const int width, const int height,
- const bool useColor);
+ const bool useColor) = 0;
void setMainFlags(int w, int h, int bpp, bool fs,
@@ -391,15 +367,9 @@ class Graphics : public gcn::SDLGraphics
bool videoInfo();
- int SDL_FakeUpperBlit(const SDL_Surface *const src,
- SDL_Rect *const srcrect,
- const SDL_Surface *const dst,
- SDL_Rect *dstrect) const;
-
int mBpp;
bool mFullscreen;
bool mHWAccel;
- BlitMode mBlitMode;
bool mRedraw;
bool mDoubleBuffer;
SDL_Rect mRect;
@@ -407,8 +377,6 @@ class Graphics : public gcn::SDLGraphics
int mOpenGL;
bool mEnableResize;
bool mNoFrame;
- uint32_t mOldPixel;
- int mOldAlpha;
std::string mName;
int mStartFreeMem;
bool mSync;
diff --git a/src/graphicsmanager.cpp b/src/graphicsmanager.cpp
index 7628b19fc..3bba8f9af 100644
--- a/src/graphicsmanager.cpp
+++ b/src/graphicsmanager.cpp
@@ -41,6 +41,7 @@
#include "graphicsvertexes.h"
#include "logger.h"
#include "mgl.h"
+#include "sdlgraphics.h"
#include "resources/fboinfo.h"
#include "resources/imagehelper.h"
@@ -228,7 +229,7 @@ void GraphicsManager::initGraphics(const bool noOpenGL)
case 0:
imageHelper = new SDLImageHelper;
sdlImageHelper = imageHelper;
- mainGraphics = new Graphics;
+ mainGraphics = new SDLGraphics;
mUseTextureSampler = false;
break;
case 1:
@@ -261,7 +262,7 @@ void GraphicsManager::initGraphics(const bool noOpenGL A_UNUSED)
// Create the graphics context
imageHelper = new SDLImageHelper;
sdlImageHelper = imageHelper;
- mainGraphics = new Graphics;
+ mainGraphics = new SDLGraphics;
#endif
}
diff --git a/src/maplayer.cpp b/src/maplayer.cpp
index 980a9a786..81561d94a 100644
--- a/src/maplayer.cpp
+++ b/src/maplayer.cpp
@@ -227,7 +227,7 @@ void MapLayer::updateSDL(Graphics *const graphics, int startX, int startY,
row->images.push_back(imgVert);
lastImage = img;
}
- graphics->calcTile(imgVert, px, py);
+ graphics->calcTileSDL(imgVert, px, py);
}
}
}
diff --git a/src/mobileopenglgraphics.h b/src/mobileopenglgraphics.h
index 4f96ce1df..c41a15a04 100644
--- a/src/mobileopenglgraphics.h
+++ b/src/mobileopenglgraphics.h
@@ -201,8 +201,6 @@ class MobileOpenGLGraphics final : public Graphics
void setTexturingAndBlending(const bool enable);
- void updateMemoryInfo();
-
void debugBindTexture(const Image *image);
private:
diff --git a/src/normalopenglgraphics.h b/src/normalopenglgraphics.h
index 9da63c32c..3b6dc0c19 100644
--- a/src/normalopenglgraphics.h
+++ b/src/normalopenglgraphics.h
@@ -212,8 +212,6 @@ class NormalOpenGLGraphics final : public Graphics
void setTexturingAndBlending(const bool enable);
- void updateMemoryInfo();
-
void debugBindTexture(const Image *const image);
private:
diff --git a/src/nullopenglgraphics.h b/src/nullopenglgraphics.h
index 7f58e1242..73c08b81e 100644
--- a/src/nullopenglgraphics.h
+++ b/src/nullopenglgraphics.h
@@ -209,8 +209,6 @@ class NullOpenGLGraphics final : public Graphics
void setTexturingAndBlending(const bool enable);
- void updateMemoryInfo();
-
void debugBindTexture(const Image *const image);
private:
diff --git a/src/resources/atlasmanager.cpp b/src/resources/atlasmanager.cpp
index 0f7565ecd..1d7147d72 100644
--- a/src/resources/atlasmanager.cpp
+++ b/src/resources/atlasmanager.cpp
@@ -25,9 +25,9 @@
#include "resources/atlasmanager.h"
#include "client.h"
-#include "graphics.h"
#include "graphicsmanager.h"
#include "logger.h"
+#include "sdlgraphics.h"
#include "utils/mathutils.h"
#include "utils/physfsrwops.h"
@@ -227,7 +227,7 @@ SDL_Surface *AtlasManager::createSDLAtlas(TextureAtlas *const atlas)
if (!surface)
return nullptr;
- Graphics *const graphics = new Graphics();
+ SDLGraphics *const graphics = new SDLGraphics();
graphics->setTarget(surface);
graphics->_beginDraw();
diff --git a/src/resources/image.h b/src/resources/image.h
index 5ac239471..556109564 100644
--- a/src/resources/image.h
+++ b/src/resources/image.h
@@ -55,6 +55,7 @@ class Image : public Resource
friend class Graphics;
friend class ImageHelper;
friend class OpenGLImageHelper;
+ friend class SDLGraphics;
friend class SDLImageHelper;
#ifdef USE_OPENGL
friend class AtlasManager;
diff --git a/src/safeopenglgraphics.cpp b/src/safeopenglgraphics.cpp
index 35748f539..2e8666e55 100644
--- a/src/safeopenglgraphics.cpp
+++ b/src/safeopenglgraphics.cpp
@@ -345,10 +345,28 @@ void SafeOpenGLGraphics::calcTile(ImageVertexes *const vert A_UNUSED,
{
}
+void SafeOpenGLGraphics::calcImagePattern(ImageVertexes *const vert,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const
+{
+}
+
+void SafeOpenGLGraphics::calcImagePattern(ImageCollection *const vert,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const
+{
+}
+
void SafeOpenGLGraphics::drawTile(const ImageVertexes *const vert A_UNUSED)
{
}
+void SafeOpenGLGraphics::drawTile(const ImageCollection *const vertCol)
+{
+}
+
void SafeOpenGLGraphics::updateScreen()
{
BLOCK_START("Graphics::updateScreen")
@@ -358,6 +376,13 @@ void SafeOpenGLGraphics::updateScreen()
BLOCK_END("Graphics::updateScreen")
}
+bool SafeOpenGLGraphics::calcWindow(ImageCollection *const vertCol,
+ const int x, const int y,
+ const int w, const int h,
+ const ImageRect &imgRect)
+{
+}
+
void SafeOpenGLGraphics::_beginDraw()
{
glMatrixMode(GL_TEXTURE);
diff --git a/src/safeopenglgraphics.h b/src/safeopenglgraphics.h
index c134caa2d..469c4cda0 100644
--- a/src/safeopenglgraphics.h
+++ b/src/safeopenglgraphics.h
@@ -89,10 +89,27 @@ class SafeOpenGLGraphics final : public Graphics
void calcTile(ImageCollection *const vertCol,
const Image *const image, int x, int y) override;
+ void calcImagePattern(ImageVertexes *const vert,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const;
+
+ void calcImagePattern(ImageCollection *const vert,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const;
+
void drawTile(const ImageVertexes *const vert) override;
+ void drawTile(const ImageCollection *const vertCol) override;
+
void updateScreen() override;
+ bool calcWindow(ImageCollection *const vertCol,
+ const int x, const int y,
+ const int w, const int h,
+ const ImageRect &imgRect);
+
void _beginDraw();
void _endDraw();
diff --git a/src/sdlgraphics.cpp b/src/sdlgraphics.cpp
new file mode 100644
index 000000000..81970b0e3
--- /dev/null
+++ b/src/sdlgraphics.cpp
@@ -0,0 +1,773 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2004-2009 The Mana World Development Team
+ * Copyright (C) 2009-2010 The Mana Developers
+ * Copyright (C) 2011-2013 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/>.
+ */
+
+#include "sdlgraphics.h"
+
+#include "main.h"
+
+#include "configuration.h"
+#include "graphicsmanager.h"
+#include "graphicsvertexes.h"
+#include "logger.h"
+
+#include "resources/imagehelper.h"
+
+#include <guichan/sdl/sdlpixel.hpp>
+
+#include <SDL_gfxBlitFunc.h>
+
+#include "debug.h"
+
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+static unsigned int *cR = nullptr;
+static unsigned int *cG = nullptr;
+static unsigned int *cB = nullptr;
+#endif
+
+SDLGraphics::SDLGraphics() :
+ Graphics(),
+ mBlitMode(BLIT_NORMAL),
+ mOldPixel(0),
+ mOldAlpha(0)
+{
+}
+
+SDLGraphics::~SDLGraphics()
+{
+}
+
+bool SDLGraphics::drawRescaledImage(const Image *const image, int srcX, int srcY,
+ int dstX, int dstY,
+ const int width, const int height,
+ const int desiredWidth,
+ const int desiredHeight,
+ const bool useColor A_UNUSED)
+{
+ FUNC_BLOCK("Graphics::drawRescaledImage", 1)
+ // Check that preconditions for blitting are met.
+ if (!mTarget || !image)
+ return false;
+ if (!image->mSDLSurface)
+ return false;
+
+ Image *const tmpImage = image->SDLgetScaledImage(
+ desiredWidth, desiredHeight);
+
+ if (!tmpImage)
+ return false;
+ if (!tmpImage->mSDLSurface)
+ return false;
+
+ dstX += mClipStack.top().xOffset;
+ dstY += mClipStack.top().yOffset;
+
+ srcX += image->mBounds.x;
+ srcY += image->mBounds.y;
+
+ SDL_Rect dstRect;
+ SDL_Rect srcRect;
+ dstRect.x = static_cast<int16_t>(dstX);
+ dstRect.y = static_cast<int16_t>(dstY);
+ srcRect.x = static_cast<int16_t>(srcX);
+ srcRect.y = static_cast<int16_t>(srcY);
+ srcRect.w = static_cast<uint16_t>(width);
+ srcRect.h = static_cast<uint16_t>(height);
+
+ const bool returnValue = !(SDL_BlitSurface(tmpImage->mSDLSurface,
+ &srcRect, mTarget, &dstRect) < 0);
+
+ delete tmpImage;
+
+ return returnValue;
+}
+
+bool SDLGraphics::drawImage2(const Image *const image, int srcX, int srcY,
+ int dstX, int dstY, const int width,
+ const int height, const bool useColor A_UNUSED)
+{
+ FUNC_BLOCK("Graphics::drawImage2", 1)
+ // Check that preconditions for blitting are met.
+ if (!mTarget || !image || !image->mSDLSurface)
+ return false;
+
+ dstX += mClipStack.top().xOffset;
+ dstY += mClipStack.top().yOffset;
+
+ srcX += image->mBounds.x;
+ srcY += image->mBounds.y;
+
+ SDL_Rect dstRect;
+ SDL_Rect srcRect;
+ dstRect.x = static_cast<int16_t>(dstX);
+ dstRect.y = static_cast<int16_t>(dstY);
+ srcRect.x = static_cast<int16_t>(srcX);
+ srcRect.y = static_cast<int16_t>(srcY);
+ srcRect.w = static_cast<uint16_t>(width);
+ srcRect.h = static_cast<uint16_t>(height);
+
+ if (mBlitMode == BLIT_NORMAL)
+ {
+ return !(SDL_BlitSurface(image->mSDLSurface, &srcRect,
+ mTarget, &dstRect) < 0);
+ }
+ else
+ {
+ return !(SDL_gfxBlitRGBA(image->mSDLSurface, &srcRect,
+ mTarget, &dstRect) < 0);
+ }
+}
+
+void SDLGraphics::drawImagePattern(const Image *const image,
+ const int x, const int y,
+ const int w, const int h)
+{
+ FUNC_BLOCK("Graphics::drawImagePattern", 1)
+ // Check that preconditions for blitting are met.
+ if (!mTarget || !image)
+ return;
+ if (!image->mSDLSurface)
+ return;
+
+ const int iw = image->mBounds.w;
+ const int ih = image->mBounds.h;
+
+ if (iw == 0 || ih == 0)
+ return;
+
+ for (int py = 0; py < h; py += ih) // Y position on pattern plane
+ {
+ const int dh = (py + ih >= h) ? h - py : ih;
+ const int srcY = image->mBounds.y;
+ const int dstY = y + py + mClipStack.top().yOffset;
+
+ for (int px = 0; px < w; px += iw) // X position on pattern plane
+ {
+ const int dw = (px + iw >= w) ? w - px : iw;
+ const int srcX = image->mBounds.x;
+ const int dstX = x + px + mClipStack.top().xOffset;
+
+ SDL_Rect dstRect;
+ SDL_Rect srcRect;
+ dstRect.x = static_cast<int16_t>(dstX);
+ dstRect.y = static_cast<int16_t>(dstY);
+ srcRect.x = static_cast<int16_t>(srcX);
+ srcRect.y = static_cast<int16_t>(srcY);
+ srcRect.w = static_cast<uint16_t>(dw);
+ srcRect.h = static_cast<uint16_t>(dh);
+
+ SDL_BlitSurface(image->mSDLSurface, &srcRect, mTarget, &dstRect);
+ }
+ }
+}
+
+void SDLGraphics::drawRescaledImagePattern(const Image *const image,
+ const int x, const int y,
+ const int w, const int h,
+ const int scaledWidth,
+ const int scaledHeight)
+{
+ // Check that preconditions for blitting are met.
+ if (!mTarget || !image)
+ return;
+ if (!image->mSDLSurface)
+ return;
+
+ if (scaledHeight == 0 || scaledWidth == 0)
+ return;
+
+ Image *const tmpImage = image->SDLgetScaledImage(
+ scaledWidth, scaledHeight);
+ if (!tmpImage)
+ return;
+
+ const int iw = tmpImage->mBounds.w;
+ const int ih = tmpImage->mBounds.h;
+
+ if (iw == 0 || ih == 0)
+ return;
+
+ for (int py = 0; py < h; py += ih) // Y position on pattern plane
+ {
+ const int dh = (py + ih >= h) ? h - py : ih;
+ const int srcY = tmpImage->mBounds.y;
+ const int dstY = y + py + mClipStack.top().yOffset;
+
+ for (int px = 0; px < w; px += iw) // X position on pattern plane
+ {
+ const int dw = (px + iw >= w) ? w - px : iw;
+ const int srcX = tmpImage->mBounds.x;
+ const int dstX = x + px + mClipStack.top().xOffset;
+
+ SDL_Rect dstRect;
+ SDL_Rect srcRect;
+ dstRect.x = static_cast<int16_t>(dstX);
+ dstRect.y = static_cast<int16_t>(dstY);
+ srcRect.x = static_cast<int16_t>(srcX);
+ srcRect.y = static_cast<int16_t>(srcY);
+ srcRect.w = static_cast<uint16_t>(dw);
+ srcRect.h = static_cast<uint16_t>(dh);
+
+ SDL_BlitSurface(tmpImage->mSDLSurface, &srcRect,
+ mTarget, &dstRect);
+ }
+ }
+
+ delete tmpImage;
+}
+
+void SDLGraphics::calcImagePattern(ImageVertexes* const vert,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const
+{
+ // Check that preconditions for blitting are met.
+ if (!vert || !mTarget || !image || !image->mSDLSurface)
+ return;
+
+ const int iw = image->mBounds.w;
+ const int ih = image->mBounds.h;
+
+ if (iw == 0 || ih == 0)
+ return;
+
+ for (int py = 0; py < h; py += ih) // Y position on pattern plane
+ {
+ const int dh = (py + ih >= h) ? h - py : ih;
+ const int srcY = image->mBounds.y;
+ const int dstY = y + py + mClipStack.top().yOffset;
+
+ for (int px = 0; px < w; px += iw) // X position on pattern plane
+ {
+ const int dw = (px + iw >= w) ? w - px : iw;
+ const int srcX = image->mBounds.x;
+ const int dstX = x + px + mClipStack.top().xOffset;
+
+ DoubleRect *const r = new DoubleRect();
+ SDL_Rect &dstRect = r->dst;
+ SDL_Rect &srcRect = r->src;
+ dstRect.x = static_cast<int16_t>(dstX);
+ dstRect.y = static_cast<int16_t>(dstY);
+ srcRect.x = static_cast<int16_t>(srcX);
+ srcRect.y = static_cast<int16_t>(srcY);
+ srcRect.w = static_cast<uint16_t>(dw);
+ srcRect.h = static_cast<uint16_t>(dh);
+
+ if (SDL_FakeUpperBlit(image->mSDLSurface, &srcRect,
+ mTarget, &dstRect) == 1)
+ {
+ vert->sdl.push_back(r);
+ }
+ else
+ {
+ delete r;
+ }
+ }
+ }
+}
+
+void SDLGraphics::calcImagePattern(ImageCollection* const vertCol,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const
+{
+ ImageVertexes *vert = nullptr;
+ if (vertCol->currentImage != image)
+ {
+ vert = new ImageVertexes();
+ vertCol->currentImage = image;
+ vertCol->currentVert = vert;
+ vert->image = image;
+ vertCol->draws.push_back(vert);
+ }
+ else
+ {
+ vert = vertCol->currentVert;
+ }
+
+ calcImagePattern(vert, image, x, y, w, h);
+}
+
+void SDLGraphics::calcTile(ImageVertexes *const vert,
+ const Image *const image,
+ int x, int y) const
+{
+ vert->image = image;
+ calcTileSDL(vert, x, y);
+}
+
+void SDLGraphics::calcTileSDL(ImageVertexes *const vert, int x, int y) const
+{
+ // Check that preconditions for blitting are met.
+ if (!vert || !vert->image || !vert->image->mSDLSurface)
+ return;
+
+ const Image *const image = vert->image;
+
+ x += mClipStack.top().xOffset;
+ y += mClipStack.top().yOffset;
+
+ DoubleRect *rect = new DoubleRect();
+
+ rect->dst.x = static_cast<int16_t>(x);
+ rect->dst.y = static_cast<int16_t>(y);
+ rect->src.x = static_cast<int16_t>(image->mBounds.x);
+ rect->src.y = static_cast<int16_t>(image->mBounds.y);
+ rect->src.w = static_cast<uint16_t>(image->mBounds.w);
+ rect->src.h = static_cast<uint16_t>(image->mBounds.h);
+ if (SDL_FakeUpperBlit(image->mSDLSurface, &rect->src,
+ mTarget, &rect->dst) == 1)
+ {
+ vert->sdl.push_back(rect);
+ }
+ else
+ {
+ delete rect;
+ }
+}
+
+void SDLGraphics::calcTile(ImageCollection *const vertCol,
+ const Image *const image,
+ int x, int y)
+{
+ if (vertCol->currentImage != image)
+ {
+ ImageVertexes *const vert = new ImageVertexes();
+ vertCol->currentImage = image;
+ vertCol->currentVert = vert;
+ vert->image = image;
+ vertCol->draws.push_back(vert);
+ calcTileSDL(vert, x, y);
+ }
+ else
+ {
+ calcTileSDL(vertCol->currentVert, x, y);
+ }
+}
+
+void SDLGraphics::drawTile(const ImageCollection *const vertCol)
+{
+ const ImageVertexesVector &draws = vertCol->draws;
+ const ImageCollectionCIter it_end = draws.end();
+ for (ImageCollectionCIter it = draws.begin(); it != it_end; ++ it)
+ {
+ const ImageVertexes *const vert = *it;
+ const Image *const img = vert->image;
+ const DoubleRects *const rects = &vert->sdl;
+ DoubleRects::const_iterator it2 = rects->begin();
+ const DoubleRects::const_iterator it2_end = rects->end();
+ while (it2 != it2_end)
+ {
+ SDL_LowerBlit(img->mSDLSurface, &(*it2)->src,
+ mTarget, &(*it2)->dst);
+ ++ it2;
+ }
+ }
+}
+
+void SDLGraphics::drawTile(const ImageVertexes *const vert)
+{
+ // vert and img must be != 0
+ const Image *const img = vert->image;
+ const DoubleRects *const rects = &vert->sdl;
+ DoubleRects::const_iterator it = rects->begin();
+ const DoubleRects::const_iterator it_end = rects->end();
+ while (it != it_end)
+ {
+ SDL_LowerBlit(img->mSDLSurface, &(*it)->src, mTarget, &(*it)->dst);
+ ++ it;
+ }
+}
+
+void SDLGraphics::updateScreen()
+{
+ BLOCK_START("Graphics::updateScreen")
+ if (mDoubleBuffer)
+ {
+ SDL_Flip(mTarget);
+ }
+ else
+ {
+ SDL_UpdateRects(mTarget, 1, &mRect);
+// SDL_UpdateRect(mTarget, 0, 0, 0, 0);
+ }
+ BLOCK_END("Graphics::updateScreen")
+}
+
+SDL_Surface *SDLGraphics::getScreenshot()
+{
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+ const int rmask = 0xff000000;
+ const int gmask = 0x00ff0000;
+ const int bmask = 0x0000ff00;
+#else
+ const int rmask = 0x000000ff;
+ const int gmask = 0x0000ff00;
+ const int bmask = 0x00ff0000;
+#endif
+ const int amask = 0x00000000;
+
+ SDL_Surface *const screenshot = SDL_CreateRGBSurface(SDL_SWSURFACE,
+ mTarget->w, mTarget->h, 24, rmask, gmask, bmask, amask);
+
+ if (screenshot)
+ SDL_BlitSurface(mTarget, nullptr, screenshot, nullptr);
+
+ return screenshot;
+}
+
+bool SDLGraphics::drawNet(const int x1, const int y1,
+ const int x2, const int y2,
+ const int width, const int height)
+{
+ for (int y = y1; y < y2; y += height)
+ drawLine(x1, y, x2, y);
+
+ for (int x = x1; x < x2; x += width)
+ drawLine(x, y1, x, y2);
+
+ return true;
+}
+
+bool SDLGraphics::calcWindow(ImageCollection *const vertCol,
+ const int x, const int y,
+ const int w, const int h,
+ const ImageRect &imgRect)
+{
+ ImageVertexes *vert = nullptr;
+ Image *const image = imgRect.grid[4];
+ if (vertCol->currentImage != image)
+ {
+ vert = new ImageVertexes();
+ vertCol->currentImage = image;
+ vertCol->currentVert = vert;
+ vert->image = image;
+ vertCol->draws.push_back(vert);
+ }
+ else
+ {
+ vert = vertCol->currentVert;
+ }
+
+ return calcImageRect(vert, x, y, w, h,
+ imgRect.grid[0], imgRect.grid[2], imgRect.grid[6], imgRect.grid[8],
+ imgRect.grid[1], imgRect.grid[5], imgRect.grid[7], imgRect.grid[3],
+ imgRect.grid[4]);
+}
+
+int SDLGraphics::SDL_FakeUpperBlit(const SDL_Surface *const src,
+ SDL_Rect *const srcrect,
+ const SDL_Surface *const dst,
+ SDL_Rect *dstrect) const
+{
+ SDL_Rect fulldst;
+ int srcx, srcy, w, h;
+
+ // Make sure the surfaces aren't locked
+ if (!src || !dst)
+ return -1;
+
+ if (src->locked || dst->locked)
+ return -1;
+
+ // If the destination rectangle is nullptr, use the entire dest surface
+ if (!dstrect)
+ {
+ fulldst.x = 0;
+ fulldst.y = 0;
+ dstrect = &fulldst;
+ }
+
+ // clip the source rectangle to the source surface
+ if (srcrect)
+ {
+ srcx = srcrect->x;
+ w = srcrect->w;
+ if (srcx < 0)
+ {
+ w += srcx;
+ dstrect->x -= static_cast<int16_t>(srcx);
+ srcx = 0;
+ }
+ int maxw = src->w - srcx;
+ if (maxw < w)
+ w = maxw;
+
+ srcy = srcrect->y;
+ h = srcrect->h;
+ if (srcy < 0)
+ {
+ h += srcy;
+ dstrect->y -= static_cast<int16_t>(srcy);
+ srcy = 0;
+ }
+ int maxh = src->h - srcy;
+ if (maxh < h)
+ h = maxh;
+ }
+ else
+ {
+ srcx = 0;
+ srcy = 0;
+ w = src->w;
+ h = src->h;
+ }
+
+ // clip the destination rectangle against the clip rectangle
+ {
+ const SDL_Rect *const clip = &dst->clip_rect;
+ int dx = clip->x - dstrect->x;
+ if (dx > 0)
+ {
+ w -= dx;
+ dstrect->x += static_cast<int16_t>(dx);
+ srcx += dx;
+ }
+ dx = dstrect->x + w - clip->x - clip->w;
+ if (dx > 0)
+ w -= dx;
+
+ int dy = clip->y - dstrect->y;
+ if (dy > 0)
+ {
+ h -= dy;
+ dstrect->y += static_cast<int16_t>(dy);
+ srcy += dy;
+ }
+ dy = dstrect->y + h - clip->y - clip->h;
+ if (dy > 0)
+ h -= dy;
+ }
+
+ if (w > 0 && h > 0)
+ {
+ if (srcrect)
+ {
+ srcrect->x = static_cast<int16_t>(srcx);
+ srcrect->y = static_cast<int16_t>(srcy);
+ srcrect->w = static_cast<int16_t>(w);
+ srcrect->h = static_cast<int16_t>(h);
+ }
+ dstrect->w = static_cast<int16_t>(w);
+ dstrect->h = static_cast<int16_t>(h);
+
+ return 1;
+// return SDL_LowerBlit(src, &sr, dst, dstrect);
+ }
+ dstrect->w = dstrect->h = 0;
+ return 0;
+}
+
+void SDLGraphics::fillRectangle(const gcn::Rectangle& rectangle)
+{
+ FUNC_BLOCK("Graphics::fillRectangle", 1)
+ if (mClipStack.empty())
+ return;
+
+ const gcn::ClipRectangle& top = mClipStack.top();
+
+ gcn::Rectangle area = rectangle;
+ area.x += top.xOffset;
+ area.y += top.yOffset;
+
+ if (!area.isIntersecting(top))
+ return;
+
+ if (mAlpha)
+ {
+ const int x1 = area.x > top.x ? area.x : top.x;
+ const int y1 = area.y > top.y ? area.y : top.y;
+ const int x2 = area.x + area.width < top.x + top.width ?
+ area.x + area.width : top.x + top.width;
+ const int y2 = area.y + area.height < top.y + top.height ?
+ area.y + area.height : top.y + top.height;
+ int x, y;
+
+ SDL_LockSurface(mTarget);
+
+ const int bpp = mTarget->format->BytesPerPixel;
+ const uint32_t pixel = SDL_MapRGB(mTarget->format,
+ static_cast<uint8_t>(mColor.r), static_cast<uint8_t>(mColor.g),
+ static_cast<uint8_t>(mColor.b));
+
+ switch (bpp)
+ {
+ case 1:
+ for (y = y1; y < y2; y++)
+ {
+ uint8_t *const p = static_cast<uint8_t *>(mTarget->pixels)
+ + y * mTarget->pitch;
+ for (x = x1; x < x2; x++)
+ *(p + x) = static_cast<uint8_t>(pixel);
+ }
+ break;
+ case 2:
+ for (y = y1; y < y2; y++)
+ {
+ uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
+ + y * mTarget->pitch;
+ for (x = x1; x < x2; x++)
+ {
+ uint8_t *const p = p0 + x * 2;
+ *reinterpret_cast<uint16_t *>(p) = gcn::SDLAlpha16(
+ static_cast<uint16_t>(pixel),
+ *reinterpret_cast<uint16_t *>(p),
+ static_cast<uint8_t>(mColor.a), mTarget->format);
+ }
+ }
+ break;
+ case 3:
+ {
+ const int ca = 255 - mColor.a;
+ const int cr = mColor.r * mColor.a;
+ const int cg = mColor.g * mColor.a;
+ const int cb = mColor.b * mColor.a;
+
+ for (y = y1; y < y2; y++)
+ {
+ uint8_t *const p0 = static_cast<uint8_t *>(mTarget->pixels)
+ + y * mTarget->pitch;
+ for (x = x1; x < x2; x++)
+ {
+ uint8_t *const p = p0 + x * 3;
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+ p[2] = static_cast<uint8_t>((p[2] * ca + cb) >> 8);
+ p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
+ p[0] = static_cast<uint8_t>((p[0] * ca + cr) >> 8);
+#else
+ p[0] = static_cast<uint8_t>((p[0] * ca + cb) >> 8);
+ p[1] = static_cast<uint8_t>((p[1] * ca + cg) >> 8);
+ p[2] = static_cast<uint8_t>((p[2] * ca + cr) >> 8);
+#endif
+ }
+ }
+ break;
+ }
+ case 4:
+ {
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+ const unsigned pb = (pixel & 0xff) * mColor.a;
+ const unsigned pg = (pixel & 0xff00) * mColor.a;
+ const unsigned pr = (pixel & 0xff0000) * mColor.a;
+ const unsigned a1 = (255 - mColor.a);
+
+ for (y = y1; y < y2; y++)
+ {
+ uint8_t *p0 = static_cast<uint8_t *>(mTarget->pixels)
+ + y * mTarget->pitch;
+ for (x = x1; x < x2; x++)
+ {
+ uint8_t *p = p0 + x * 4;
+ uint32_t dst = *reinterpret_cast<uint32_t *>(p);
+ const unsigned int b = (pb + (dst & 0xff) * a1) >> 8;
+ const unsigned int g = (pg + (dst & 0xff00) * a1) >> 8;
+ const unsigned int r = (pr
+ + (dst & 0xff0000) * a1) >> 8;
+
+ *reinterpret_cast<uint32_t *>(p) = ((b & 0xff)
+ | (g & 0xff00) | (r & 0xff0000));
+ }
+ }
+#else
+ if (!cR)
+ {
+ cR = new unsigned int[0x100];
+ cG = new unsigned int[0x100];
+ cB = new unsigned int[0x100];
+ mOldPixel = 0;
+ mOldAlpha = mColor.a;
+ }
+
+ const SDL_PixelFormat * const format = mTarget->format;
+ const unsigned rMask = format->Rmask;
+ const unsigned gMask = format->Gmask;
+ const unsigned bMask = format->Bmask;
+// const unsigned aMask = format->Amask;
+ unsigned rShift = rMask / 0xff;
+ unsigned gShift = gMask / 0xff;
+ unsigned bShift = bMask / 0xff;
+ if (!rShift)
+ rShift = 1;
+ if (!gShift)
+ gShift = 1;
+ if (!bShift)
+ bShift = 1;
+ if (pixel != mOldPixel || mColor.a != mOldAlpha)
+ {
+ const unsigned pb = (pixel & bMask) * mColor.a;
+ const unsigned pg = (pixel & gMask) * mColor.a;
+ const unsigned pr = (pixel & rMask) * mColor.a;
+ const unsigned a0 = (255 - mColor.a);
+
+ const unsigned int a1 = a0 * bShift;
+ const unsigned int a2 = a0 * gShift;
+ const unsigned int a3 = a0 * rShift;
+
+ for (int f = 0; f <= 0xff; f ++)
+ {
+ cB[f] = ((pb + f * a1) >> 8) & bMask;
+ cG[f] = ((pg + f * a2) >> 8) & gMask;
+ cR[f] = ((pr + f * a3) >> 8) & rMask;
+ }
+
+ mOldPixel = pixel;
+ mOldAlpha = mColor.a;
+ }
+
+ for (y = y1; y < y2; y++)
+ {
+ uint32_t *const p0 = reinterpret_cast<uint32_t*>(
+ static_cast<uint8_t*>(mTarget->pixels)
+ + y * mTarget->pitch);
+ for (x = x1; x < x2; x++)
+ {
+ uint32_t *const p = p0 + x;
+ const uint32_t dst = *p;
+ *p = cB[dst & bMask / bShift]
+ | cG[(dst & gMask) / gShift]
+ | cR[(dst & rMask) / rShift];
+ }
+ }
+#endif
+ break;
+ }
+ default:
+ break;
+ }
+
+ SDL_UnlockSurface(mTarget);
+ }
+ else
+ {
+ SDL_Rect rect;
+ rect.x = static_cast<int16_t>(area.x);
+ rect.y = static_cast<int16_t>(area.y);
+ rect.w = static_cast<uint16_t>(area.width);
+ rect.h = static_cast<uint16_t>(area.height);
+
+ const uint32_t color = SDL_MapRGBA(mTarget->format,
+ static_cast<int8_t>(mColor.r),
+ static_cast<int8_t>(mColor.g),
+ static_cast<int8_t>(mColor.b),
+ static_cast<int8_t>(mColor.a));
+ SDL_FillRect(mTarget, &rect, color);
+ }
+}
diff --git a/src/sdlgraphics.h b/src/sdlgraphics.h
new file mode 100644
index 000000000..823ee9a43
--- /dev/null
+++ b/src/sdlgraphics.h
@@ -0,0 +1,140 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2004-2009 The Mana World Development Team
+ * Copyright (C) 2009-2010 The Mana Developers
+ * Copyright (C) 2011-2013 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 SDLGRAPHICS_H
+#define SDLGRAPHICS_H
+
+#include "graphics.h"
+
+#include "localconsts.h"
+
+class Image;
+class ImageCollection;
+class ImageVertexes;
+class MapLayer;
+
+struct SDL_Surface;
+
+/**
+ * A central point of control for graphics.
+ */
+class SDLGraphics : public Graphics
+{
+ public:
+ enum BlitMode
+ {
+ BLIT_NORMAL = 0,
+ BLIT_GFX
+ };
+
+ /**
+ * Constructor.
+ */
+ SDLGraphics();
+
+ A_DELETE_COPY(SDLGraphics)
+
+ /**
+ * Destructor.
+ */
+ virtual ~SDLGraphics();
+
+ virtual bool drawRescaledImage(const Image *const image, int srcX,
+ int srcY, int dstX, int dstY,
+ const int width, const int height,
+ const int desiredWidth,
+ const int desiredHeight,
+ const bool useColor = false);
+
+ virtual void drawImagePattern(const Image *const image,
+ const int x, const int y,
+ const int w, const int h);
+
+ virtual void drawRescaledImagePattern(const Image *const image,
+ const int x, const int y,
+ const int w, const int h,
+ const int scaledWidth,
+ const int scaledHeight);
+
+ virtual void calcImagePattern(ImageVertexes *const vert,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const;
+
+ virtual void calcImagePattern(ImageCollection *const vert,
+ const Image *const image,
+ const int x, const int y,
+ const int w, const int h) const;
+
+ virtual void calcTile(ImageVertexes *const vert,
+ const Image *const image, int x, int y) const;
+
+ virtual void calcTileSDL(ImageVertexes *const vert,
+ int x, int y) const;
+
+ virtual void calcTile(ImageCollection *const vertCol,
+ const Image *const image,
+ int x, int y);
+
+ virtual void drawTile(const ImageVertexes *const vert);
+
+ virtual void drawTile(const ImageCollection *const vertCol);
+
+ virtual void updateScreen();
+
+ virtual SDL_Surface *getScreenshot() A_WARN_UNUSED;
+
+ virtual bool drawNet(const int x1, const int y1,
+ const int x2, const int y2,
+ const int width, const int height);
+
+ virtual bool calcWindow(ImageCollection *const vertCol,
+ const int x, const int y,
+ const int w, const int h,
+ const ImageRect &imgRect);
+
+ void setBlitMode(const BlitMode mode)
+ { mBlitMode = mode; }
+
+ BlitMode getBlitMode() const A_WARN_UNUSED
+ { return mBlitMode; }
+
+ void fillRectangle(const gcn::Rectangle& rectangle) override;
+
+ protected:
+ virtual bool drawImage2(const Image *const image,
+ int srcX, int srcY,
+ int dstX, int dstY,
+ const int width, const int height,
+ const bool useColor);
+
+ int SDL_FakeUpperBlit(const SDL_Surface *const src,
+ SDL_Rect *const srcrect,
+ const SDL_Surface *const dst,
+ SDL_Rect *dstrect) const;
+
+ BlitMode mBlitMode;
+ uint32_t mOldPixel;
+ int mOldAlpha;
+};
+
+#endif // SDLGRAPHICS_H