From 2ab3f0d8d04374b330c91a9f065efa0f526d7824 Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sun, 1 Sep 2013 20:50:30 +0300 Subject: add software renderer for SDL2. before it used default renderer with software flags. --- src/CMakeLists.txt | 4 + src/Makefile.am | 8 +- src/graphicsmanager.cpp | 8 +- src/gui/widgets/desktop.cpp | 6 - src/render/sdl2softwaregraphics.cpp | 1283 +++++++++++++++++++++++++++++ src/render/sdl2softwaregraphics.h | 157 ++++ src/resources/image.cpp | 10 +- src/resources/image.h | 2 + src/resources/sdl2softwareimagehelper.cpp | 184 +++++ src/resources/sdl2softwareimagehelper.h | 113 +++ 10 files changed, 1761 insertions(+), 14 deletions(-) create mode 100644 src/render/sdl2softwaregraphics.cpp create mode 100644 src/render/sdl2softwaregraphics.h create mode 100644 src/resources/sdl2softwareimagehelper.cpp create mode 100644 src/resources/sdl2softwareimagehelper.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 6e2aede86..26bd600d2 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -490,6 +490,8 @@ SET(SRCS resources/resourcemanager.h resources/sdl2imagehelper.cpp resources/sdl2imagehelper.h + resources/sdl2softwareimagehelper.cpp + resources/sdl2softwareimagehelper.h resources/sdlimagehelper.cpp resources/sdlimagehelper.h resources/sdlmusic.cpp @@ -706,6 +708,8 @@ SET(SRCS render/safeopenglgraphics.h render/sdl2graphics.cpp render/sdl2graphics.h + render/sdl2softwaregraphics.cpp + render/sdl2softwaregraphics.h render/sdlgraphics.cpp render/sdlgraphics.h sdlshared.h diff --git a/src/Makefile.am b/src/Makefile.am index 84a9444a9..8332f02cd 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -32,7 +32,9 @@ endif if USE_SDL2 manaplus_CXXFLAGS += -I$(srcdir)/sdl2gfx -DUSE_SDL2 manaplus_SOURCES += sdl2gfx/SDL_framerate.c \ - sdl2gfx/SDL_framerate.h + sdl2gfx/SDL_framerate.h \ + sdl2gfx/SDL_rotozoom.c \ + sdl2gfx/SDL_rotozoom.h endif if USE_INTERNALGUICHAN @@ -499,6 +501,8 @@ manaplus_SOURCES += gui/widgets/avatarlistbox.cpp \ resources/resourcemanager.h \ resources/sdl2imagehelper.cpp \ resources/sdl2imagehelper.h \ + resources/sdl2softwareimagehelper.cpp \ + resources/sdl2softwareimagehelper.h \ resources/sdlimagehelper.cpp \ resources/sdlimagehelper.h \ resources/sdlmusic.cpp \ @@ -715,6 +719,8 @@ manaplus_SOURCES += gui/widgets/avatarlistbox.cpp \ render/safeopenglgraphics.h \ render/sdl2graphics.cpp \ render/sdl2graphics.h \ + render/sdl2softwaregraphics.cpp \ + render/sdl2softwaregraphics.h \ render/sdlgraphics.cpp \ render/sdlgraphics.h \ sdlshared.h \ diff --git a/src/graphicsmanager.cpp b/src/graphicsmanager.cpp index 1c6f81233..471bcb630 100644 --- a/src/graphicsmanager.cpp +++ b/src/graphicsmanager.cpp @@ -43,11 +43,13 @@ #include "render/graphics.h" #include "render/renderers.h" +#include "render/sdl2softwaregraphics.h" #include "render/sdlgraphics.h" #include "resources/fboinfo.h" #include "resources/imagehelper.h" #include "resources/openglimagehelper.h" +#include "resources/sdl2softwareimagehelper.h" #include "resources/sdlimagehelper.h" #include "resources/surfaceimagehelper.h" @@ -231,13 +233,15 @@ void GraphicsManager::initGraphics(const bool noOpenGL) switch (useOpenGL) { case RENDER_SOFTWARE: - imageHelper = new SDLImageHelper; #ifdef USE_SDL2 + imageHelper = new SDL2SoftwareImageHelper; surfaceImageHelper = new SurfaceImageHelper; + mainGraphics = new SDL2SoftwareGraphics; #else + imageHelper = new SDLImageHelper; surfaceImageHelper = imageHelper; -#endif mainGraphics = new SDLGraphics; +#endif mUseTextureSampler = false; break; case RENDER_NORMAL_OPENGL: diff --git a/src/gui/widgets/desktop.cpp b/src/gui/widgets/desktop.cpp index 93b0a96e7..07a49c420 100644 --- a/src/gui/widgets/desktop.cpp +++ b/src/gui/widgets/desktop.cpp @@ -99,7 +99,6 @@ void Desktop::draw(gcn::Graphics *graphics) g->fillRectangle(gcn::Rectangle(0, 0, width, height)); } -#ifndef USE_SDL2 if (imageHelper->useOpenGL() == RENDER_SOFTWARE) { g->drawImage(mWallpaper, @@ -107,7 +106,6 @@ void Desktop::draw(gcn::Graphics *graphics) (height - wallpHeight) / 2); } else -#endif { g->drawRescaledImage(mWallpaper, 0, 0, 0, 0, wallpWidth, wallpHeight, @@ -150,11 +148,7 @@ void Desktop::setBestFittingWallpaper() const int width = rect.width; const int height = rect.height; -#ifdef USE_SDL2 - if (false && -#else if (imageHelper->useOpenGL() == RENDER_SOFTWARE && -#endif (nWallPaper->getWidth() != width || nWallPaper->getHeight() != height)) { diff --git a/src/render/sdl2softwaregraphics.cpp b/src/render/sdl2softwaregraphics.cpp new file mode 100644 index 000000000..857909636 --- /dev/null +++ b/src/render/sdl2softwaregraphics.cpp @@ -0,0 +1,1283 @@ +/* + * 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 . + */ + +#ifdef USE_SDL2 + +#include "render/sdl2softwaregraphics.h" + +#include "main.h" + +#include "configuration.h" +#include "graphicsmanager.h" +#include "graphicsvertexes.h" +#include "logger.h" + +#include "resources/imagehelper.h" +#include "resources/sdl2imagehelper.h" + +#include + +#include "utils/sdlcheckutils.h" + +#include + +#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 + +SDL2SoftwareGraphics::SDL2SoftwareGraphics() : + Graphics(), + mRendererFlags(SDL_RENDERER_SOFTWARE), + mSurface(nullptr), + mOldPixel(0), + mOldAlpha(0) +{ + mOpenGL = RENDER_SOFTWARE; + mName = "Software"; +} + +SDL2SoftwareGraphics::~SDL2SoftwareGraphics() +{ +} + +bool SDL2SoftwareGraphics::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 (!mSurface || !image) + return false; + if (!image->mSDLSurface) + return false; + + Image *const tmpImage = image->SDLgetScaledImage( + desiredWidth, desiredHeight); + + if (!tmpImage) + return false; + if (!tmpImage->mSDLSurface) + return false; + + const gcn::ClipRectangle &top = mClipStack.top(); + const SDL_Rect &bounds = image->mBounds; + + SDL_Rect srcRect = + { + static_cast(srcX + bounds.x), + static_cast(srcY + bounds.y), + static_cast(width), + static_cast(height) + }; + + SDL_Rect dstRect = + { + static_cast(dstX + top.xOffset), + static_cast(dstY + top.yOffset), + 0, + 0 + }; + + const bool returnValue = !(SDL_BlitSurface(tmpImage->mSDLSurface, + &srcRect, mSurface, &dstRect) < 0); + + delete tmpImage; + + return returnValue; +} + +bool SDL2SoftwareGraphics::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 (!mSurface || !image || !image->mSDLSurface) + return false; + + const gcn::ClipRectangle &top = mClipStack.top(); + const SDL_Rect &bounds = image->mBounds; + + + SDL_Surface *const src = image->mSDLSurface; + + srcX += bounds.x; + srcY += bounds.y; + dstX += top.xOffset; + dstY += top.yOffset; + + int w = width; + int h = height; + if (srcX < 0) + { + w += srcX; + dstX -= static_cast(srcX); + srcX = 0; + } + const int maxw = src->w - srcX; + if (maxw < w) + w = maxw; + + if (srcY < 0) + { + h += srcY; + dstY -= static_cast(srcY); + srcY = 0; + } + const int maxh = src->h - srcY; + if (maxh < h) + h = maxh; + + const SDL_Rect *const clip = &mSurface->clip_rect; + const int clipX = clip->x; + const int clipY = clip->y; + int dx = clipX - dstX; + if (dx > 0) + { + w -= dx; + dstX += static_cast(dx); + srcX += dx; + } + dx = dstX + w - clipX - clip->w; + if (dx > 0) + w -= dx; + + int dy = clipY - dstY; + if (dy > 0) + { + h -= dy; + dstY += static_cast(dy); + srcY += dy; + } + dy = dstY + h - clipY - clip->h; + if (dy > 0) + h -= dy; + + if (w > 0 && h > 0) + { + SDL_Rect srcRect = + { + static_cast(srcX), + static_cast(srcY), + static_cast(w), + static_cast(h) + }; + + SDL_Rect dstRect = + { + static_cast(dstX), + static_cast(dstY), + static_cast(w), + static_cast(h) + }; + + return SDL_LowerBlit(src, &srcRect, mSurface, &dstRect); + } + return 0; +} + +void SDL2SoftwareGraphics::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 (!mSurface || !image) + return; + if (!image->mSDLSurface) + return; + + const SDL_Rect &bounds = image->mBounds; + const int iw = bounds.w; + const int ih = bounds.h; + if (iw == 0 || ih == 0) + return; + + const gcn::ClipRectangle &top = mClipStack.top(); + const int xOffset = top.xOffset + x; + const int yOffset = top.yOffset + y; + const int srcX = bounds.x; + const int srcY = bounds.y; + SDL_Surface *const src = image->mSDLSurface; + const SDL_Rect *const clip = &mSurface->clip_rect; + const int clipX = clip->x; + const int clipY = clip->y; + + for (int py = 0; py < h; py += ih) + { + const int dh = (py + ih >= h) ? h - py : ih; + int dstY = py + yOffset; + int y2 = srcY; + int h2 = dh; + if (y2 < 0) + { + h2 += y2; + dstY -= static_cast(y2); + y2 = 0; + } + const int maxh = src->h - y2; + if (maxh < h2) + h2 = maxh; + + int dy = clipY - dstY; + if (dy > 0) + { + h2 -= dy; + dstY += static_cast(dy); + y2 += dy; + } + dy = dstY + h2 - clipY - clip->h; + if (dy > 0) + h2 -= dy; + + if (h2 > 0) + { + for (int px = 0; px < w; px += iw) + { + const int dw = (px + iw >= w) ? w - px : iw; + int dstX = px + xOffset; + int x2 = srcX; + int w2 = dw; + if (x2 < 0) + { + w2 += x2; + dstX -= static_cast(x2); + x2 = 0; + } + const int maxw = src->w - x2; + if (maxw < w2) + w2 = maxw; + + int dx = clipX - dstX; + if (dx > 0) + { + w2 -= dx; + dstX += static_cast(dx); + x2 += dx; + } + dx = dstX + w2 - clipX - clip->w; + if (dx > 0) + w2 -= dx; + + if (w2 > 0) + { + SDL_Rect srcRect = + { + static_cast(x2), + static_cast(y2), + static_cast(w2), + static_cast(h2) + }; + + SDL_Rect dstRect = + { + static_cast(dstX), + static_cast(dstY), + static_cast(w2), + static_cast(h2) + }; + + SDL_LowerBlit(src, &srcRect, mSurface, &dstRect); + } + +// SDL_BlitSurface(image->mSDLSurface, &srcRect, mWindow, &dstRect); + } + } + } +} + +void SDL2SoftwareGraphics::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 (!mSurface || !image) + return; + if (!image->mSDLSurface) + return; + + if (scaledHeight == 0 || scaledWidth == 0) + return; + + Image *const tmpImage = image->SDLgetScaledImage( + scaledWidth, scaledHeight); + if (!tmpImage) + return; + + const SDL_Rect &bounds = tmpImage->mBounds; + const int iw = bounds.w; + const int ih = bounds.h; + if (iw == 0 || ih == 0) + return; + + const gcn::ClipRectangle &top = mClipStack.top(); + const int xOffset = top.xOffset + x; + const int yOffset = top.yOffset + y; + const int srcX = bounds.x; + const int srcY = bounds.y; + + for (int py = 0; py < h; py += ih) // Y position on pattern plane + { + const int dh = (py + ih >= h) ? h - py : ih; + const int dstY = py + 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 dstX = px + xOffset; + + SDL_Rect srcRect = + { + static_cast(srcX), + static_cast(srcY), + static_cast(dw), + static_cast(dh) + }; + + SDL_Rect dstRect = + { + static_cast(dstX), + static_cast(dstY), + 0, + 0 + }; + + SDL_BlitSurface(tmpImage->mSDLSurface, &srcRect, + mSurface, &dstRect); + } + } + + delete tmpImage; +} + +void SDL2SoftwareGraphics::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 || !mSurface || !image || !image->mSDLSurface) + return; + + const SDL_Rect &bounds = image->mBounds; + const int iw = bounds.w; + const int ih = bounds.h; + if (iw == 0 || ih == 0) + return; + + const gcn::ClipRectangle &top = mClipStack.top(); + const int xOffset = top.xOffset + x; + const int yOffset = top.yOffset + y; + const int srcX = bounds.x; + const int srcY = bounds.y; + + for (int py = 0; py < h; py += ih) // Y position on pattern plane + { + const int dh = (py + ih >= h) ? h - py : ih; + const int dstY = py + 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 dstX = px + xOffset; + + DoubleRect *const r = new DoubleRect(); + SDL_Rect &srcRect = r->src; + srcRect.x = static_cast(srcX); + srcRect.y = static_cast(srcY); + srcRect.w = static_cast(dw); + srcRect.h = static_cast(dh); + SDL_Rect &dstRect = r->dst; + dstRect.x = static_cast(dstX); + dstRect.y = static_cast(dstY); + + if (SDL_FakeUpperBlit(image->mSDLSurface, &srcRect, + mSurface, &dstRect) == 1) + { + vert->sdl.push_back(r); + } + else + { + delete r; + } + } + } +} + +void SDL2SoftwareGraphics::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 SDL2SoftwareGraphics::calcTile(ImageVertexes *const vert, + const Image *const image, + int x, int y) const +{ + vert->image = image; + calcTileSDL(vert, x, y); +} + +void SDL2SoftwareGraphics::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; + const gcn::ClipRectangle &top = mClipStack.top(); + const SDL_Rect &bounds = image->mBounds; + + DoubleRect *rect = new DoubleRect(); + rect->src.x = static_cast(bounds.x); + rect->src.y = static_cast(bounds.y); + rect->src.w = static_cast(bounds.w); + rect->src.h = static_cast(bounds.h); + rect->dst.x = static_cast(x + top.xOffset); + rect->dst.y = static_cast(y + top.yOffset); + if (SDL_FakeUpperBlit(image->mSDLSurface, &rect->src, + mSurface, &rect->dst) == 1) + { + vert->sdl.push_back(rect); + } + else + { + delete rect; + } +} + +void SDL2SoftwareGraphics::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 SDL2SoftwareGraphics::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, + mSurface, &(*it2)->dst); + ++ it2; + } + } +} + +void SDL2SoftwareGraphics::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, mSurface, &(*it)->dst); + ++ it; + } +} + +void SDL2SoftwareGraphics::updateScreen() +{ + BLOCK_START("Graphics::updateScreen") + SDL_UpdateWindowSurfaceRects(mWindow, &mRect, 1); + BLOCK_END("Graphics::updateScreen") +} + +SDL_Surface *SDL2SoftwareGraphics::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 = MSDL_CreateRGBSurface(SDL_SWSURFACE, + mRect.w, mRect.h, 24, rmask, gmask, bmask, amask); + + if (screenshot) + SDL_BlitSurface(mSurface, nullptr, screenshot, nullptr); + + return screenshot; +} + +bool SDL2SoftwareGraphics::drawNet(const int x1, const int y1, + const int x2, const int y2, + const int width, const int height) +{ + // +++ need use SDL_RenderDrawLines + 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 SDL2SoftwareGraphics::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; + } + + const Image *const *const grid = &imgRect.grid[0]; + return calcImageRect(vert, x, y, w, h, + grid[0], grid[2], grid[6], grid[8], + grid[1], grid[5], grid[7], grid[3], + grid[4]); +} + +int SDL2SoftwareGraphics::SDL_FakeUpperBlit(const SDL_Surface *const src, + SDL_Rect *const srcrect, + const SDL_Surface *const dst, + SDL_Rect *dstrect) const +{ + int srcx, srcy, w, h; + + // Make sure the surfaces aren't locked + if (!src || !dst) + return -1; + + if (!srcrect || !dstrect) + return -1; + + srcx = srcrect->x; + w = srcrect->w; + if (srcx < 0) + { + w += srcx; + dstrect->x -= static_cast(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(srcy); + srcy = 0; + } + int maxh = src->h - srcy; + if (maxh < h) + h = maxh; + + const SDL_Rect *const clip = &dst->clip_rect; + const int clipX = clip->x; + const int clipY = clip->y; + int dx = clipX - dstrect->x; + if (dx > 0) + { + w -= dx; + dstrect->x += static_cast(dx); + srcx += dx; + } + dx = dstrect->x + w - clipX - clip->w; + if (dx > 0) + w -= dx; + + int dy = clipY - dstrect->y; + if (dy > 0) + { + h -= dy; + dstrect->y += static_cast(dy); + srcy += dy; + } + dy = dstrect->y + h - clipY - clip->h; + if (dy > 0) + h -= dy; + + if (w > 0 && h > 0) + { + if (srcrect) + { + srcrect->x = static_cast(srcx); + srcrect->y = static_cast(srcy); + srcrect->w = static_cast(w); + srcrect->h = static_cast(h); + } + dstrect->w = static_cast(w); + dstrect->h = static_cast(h); + + return 1; +// return SDL_LowerBlit(src, &sr, dst, dstrect); + } + dstrect->w = dstrect->h = 0; + return 0; +} + +void SDL2SoftwareGraphics::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(mSurface); + + const int bpp = mSurface->format->BytesPerPixel; + const uint32_t pixel = SDL_MapRGB(mSurface->format, + static_cast(mColor.r), static_cast(mColor.g), + static_cast(mColor.b)); + + switch (bpp) + { + case 1: + for (y = y1; y < y2; y++) + { + uint8_t *const p = static_cast(mSurface->pixels) + + y * mSurface->pitch; + for (x = x1; x < x2; x++) + *(p + x) = static_cast(pixel); + } + break; + case 2: + for (y = y1; y < y2; y++) + { + uint8_t *const p0 = static_cast(mSurface->pixels) + + y * mSurface->pitch; + for (x = x1; x < x2; x++) + { + uint8_t *const p = p0 + x * 2; + *reinterpret_cast(p) = gcn::SDLAlpha16( + static_cast(pixel), + *reinterpret_cast(p), + static_cast(mColor.a), mSurface->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(mSurface->pixels) + + y * mSurface->pitch; + for (x = x1; x < x2; x++) + { + uint8_t *const p = p0 + x * 3; +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + p[2] = static_cast((p[2] * ca + cb) >> 8); + p[1] = static_cast((p[1] * ca + cg) >> 8); + p[0] = static_cast((p[0] * ca + cr) >> 8); +#else + p[0] = static_cast((p[0] * ca + cb) >> 8); + p[1] = static_cast((p[1] * ca + cg) >> 8); + p[2] = static_cast((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 *const p0 = static_cast(mSurface->pixels) + + y * mSurface->pitch; + for (x = x1; x < x2; x++) + { + uint8_t *p = p0 + x * 4; + uint32_t dst = *reinterpret_cast(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(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 = mSurface->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( + static_cast(mSurface->pixels) + + y * mSurface->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(mSurface); + } + else + { + SDL_Rect rect = + { + static_cast(area.x), + static_cast(area.y), + static_cast(area.width), + static_cast(area.height) + }; + + const uint32_t color = SDL_MapRGBA(mSurface->format, + static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b), + static_cast(mColor.a)); + SDL_FillRect(mSurface, &rect, color); + } +} + +void SDL2SoftwareGraphics::_beginDraw() +{ + pushClipArea(gcn::Rectangle(0, 0, mRect.w, mRect.h)); +} + +void SDL2SoftwareGraphics::_endDraw() +{ + popClipArea(); +} + +bool SDL2SoftwareGraphics::pushClipArea(gcn::Rectangle area) +{ + const bool result = gcn::Graphics::pushClipArea(area); + + const gcn::ClipRectangle &carea = mClipStack.top(); + const SDL_Rect rect = + { + static_cast(carea.x), + static_cast(carea.y), + static_cast(carea.width), + static_cast(carea.height) + }; + SDL_SetClipRect(mSurface, &rect); + return result; +} + +void SDL2SoftwareGraphics::popClipArea() +{ + gcn::Graphics::popClipArea(); + + if (mClipStack.empty()) + return; + + const gcn::ClipRectangle &carea = mClipStack.top(); + const SDL_Rect rect = + { + static_cast(carea.x), + static_cast(carea.y), + static_cast(carea.width), + static_cast(carea.height) + }; + + SDL_SetClipRect(mSurface, &rect); +} + +void SDL2SoftwareGraphics::drawPoint(int x, int y) +{ + if (mClipStack.empty()) + return; + + const gcn::ClipRectangle& top = mClipStack.top(); + + x += top.xOffset; + y += top.yOffset; + + if (!top.isPointInRect(x, y)) + return; + + if (mAlpha) + SDLputPixelAlpha(mSurface, x, y, mColor); + else + SDLputPixel(mSurface, x, y, mColor); +} + +void SDL2SoftwareGraphics::drawHLine(int x1, int y, int x2) +{ + if (mClipStack.empty()) + return; + + const gcn::ClipRectangle& top = mClipStack.top(); + + const int xOffset = top.xOffset; + x1 += xOffset; + y += top.yOffset; + x2 += xOffset; + + const int topY = top.y; + if (y < topY || y >= topY + top.height) + return; + + if (x1 > x2) + { + x1 ^= x2; + x2 ^= x1; + x1 ^= x2; + } + + const int topX = top.x; + if (topX > x1) + { + if (topX > x2) + return; + + x1 = topX; + } + + const int sumX = topX + top.width; + if (sumX <= x2) + { + if (sumX <= x1) + return; + + x2 = sumX -1; + } + + const int bpp = mSurface->format->BytesPerPixel; + + SDL_LockSurface(mSurface); + + uint8_t *p = static_cast(mSurface->pixels) + + y * mSurface->pitch + x1 * bpp; + + const uint32_t pixel = SDL_MapRGB(mSurface->format, + static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b)); + switch (bpp) + { + case 1: + for (; x1 <= x2; ++x1) + *(p++) = static_cast(pixel); + break; + + case 2: + { + uint16_t* q = reinterpret_cast(p); + for (; x1 <= x2; ++x1) + *(q++) = pixel; + break; + } + + case 3: + { + const uint8_t b0 = static_cast((pixel >> 16) & 0xff); + const uint8_t b1 = static_cast((pixel >> 8) & 0xff); + const uint8_t b2 = static_cast(pixel & 0xff); +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + for (; x1 <= x2; ++x1) + { + p[0] = b0; + p[1] = b1; + p[2] = b2; + p += 3; + } +#else + for (; x1 <= x2; ++x1) + { + p[0] = b2; + p[1] = b1; + p[2] = b0; + p += 3; + } +#endif + break; + } + + case 4: + { + uint32_t *q = reinterpret_cast(p); + if (mAlpha) + { + unsigned char a = static_cast(mColor.a); + unsigned char a1 = 255 - a; + const int b0 = (pixel & 0xff) * a; + const int g0 = (pixel & 0xff00) * a; + const int r0 = (pixel & 0xff0000) * a; + for (; x1 <= x2; ++x1) + { + const unsigned int b = (b0 + (*q & 0xff) * a1) >> 8; + const unsigned int g = (g0 + (*q & 0xff00) * a1) >> 8; + const unsigned int r = (r0 + (*q & 0xff0000) * a1) >> 8; + *q = (b & 0xff) | (g & 0xff00) | (r & 0xff0000); + + q++; + } + } + else + { + for (; x1 <= x2; ++x1) + *(q++) = pixel; + } + break; + } + default: + break; + } // end switch + + SDL_UnlockSurface(mSurface); +} + +void SDL2SoftwareGraphics::drawVLine(int x, int y1, int y2) +{ + if (mClipStack.empty()) + return; + + const gcn::ClipRectangle& top = mClipStack.top(); + + const int yOffset = top.yOffset; + x += top.xOffset; + y1 += yOffset; + y2 += yOffset; + + if (x < top.x || x >= top.x + top.width) + return; + + if (y1 > y2) + { + y1 ^= y2; + y2 ^= y1; + y1 ^= y2; + } + + if (top.y > y1) + { + if (top.y > y2) + return; + + y1 = top.y; + } + + const int sumY = top.y + top.height; + if (sumY <= y2) + { + if (sumY <= y1) + return; + + y2 = sumY - 1; + } + + const int bpp = mSurface->format->BytesPerPixel; + + SDL_LockSurface(mSurface); + + uint8_t *p = static_cast(mSurface->pixels) + + y1 * mSurface->pitch + x * bpp; + + const uint32_t pixel = SDL_MapRGB(mSurface->format, + static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b)); + + const int pitch = mSurface->pitch; + switch (bpp) + { + case 1: + for (; y1 <= y2; ++y1) + { + *p = static_cast(pixel); + p += pitch; + } + break; + + case 2: + for (; y1 <= y2; ++ y1) + { + *reinterpret_cast(p) + = static_cast(pixel); + p += pitch; + } + break; + + case 3: + { + const uint8_t b0 = static_cast((pixel >> 16) & 0xff); + const uint8_t b1 = static_cast((pixel >> 8) & 0xff); + const uint8_t b2 = static_cast(pixel & 0xff); +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + for (; y1 <= y2; ++y1) + { + p[0] = b0; + p[1] = b1; + p[2] = b2; + p += pitch; + } +#else + for (; y1 <= y2; ++y1) + { + p[0] = b2; + p[1] = b1; + p[2] = b0; + p += pitch; + } +#endif + break; + } + + case 4: + { + if (mAlpha) + { + unsigned char a = static_cast(mColor.a); + unsigned char a1 = 255 - a; + const int b0 = (pixel & 0xff) * a; + const int g0 = (pixel & 0xff00) * a; + const int r0 = (pixel & 0xff0000) * a; + for (; y1 <= y2; ++y1) + { + const unsigned int dst = *reinterpret_cast(p); + const unsigned int b = (b0 + (dst & 0xff) * a1) >> 8; + const unsigned int g = (g0 + (dst & 0xff00) * a1) >> 8; + const unsigned int r = (r0 + (dst & 0xff0000) * a1) >> 8; + *reinterpret_cast(p) = + (b & 0xff) | (g & 0xff00) | (r & 0xff0000); + + p += pitch; + } + } + else + { + for (; y1 <= y2; ++y1) + { + *reinterpret_cast(p) = pixel; + p += pitch; + } + } + break; + } + + default: + break; + } // end switch + + SDL_UnlockSurface(mSurface); +} + +void SDL2SoftwareGraphics::drawRectangle(const gcn::Rectangle &rectangle) +{ + const int x1 = rectangle.x; + const int x2 = x1 + rectangle.width - 1; + const int y1 = rectangle.y; + const int y2 = y1 + rectangle.height - 1; + + drawHLine(x1, y1, x2); + drawHLine(x1, y2, x2); + + drawVLine(x1, y1, y2); + drawVLine(x2, y1, y2); +} + +void SDL2SoftwareGraphics::drawLine(int x1, int y1, int x2, int y2) +{ + if (x1 == x2) + { + drawVLine(x1, y1, y2); + return; + } + if (y1 == y2) + { + drawHLine(x1, y1, x2); + return; + } +} + +bool SDL2SoftwareGraphics::setVideoMode(const int w, const int h, + const int bpp, const bool fs, + const bool hwaccel, const bool resize, + const bool noFrame) +{ + setMainFlags(w, h, bpp, fs, hwaccel, resize, noFrame); + + if (!(mWindow = graphicsManager.createWindow(w, h, bpp, + getSoftwareFlags()))) + { + mRect.w = 0; + mRect.h = 0; + mSurface = nullptr; + return false; + } + + mSurface = SDL_GetWindowSurface(mWindow); + logger->log("window surface: %p", mSurface); + + int w1 = 0; + int h1 = 0; + SDL_GetWindowSize(mWindow, &w1, &h1); + mRect.w = w1; + mRect.h = h1; + + mRenderer = graphicsManager.createRenderer(mWindow, mRendererFlags); + SDLImageHelper::setRenderer(mRenderer); + return videoInfo(); +} + +#endif // USE_SDL2 diff --git a/src/render/sdl2softwaregraphics.h b/src/render/sdl2softwaregraphics.h new file mode 100644 index 000000000..7ddba5018 --- /dev/null +++ b/src/render/sdl2softwaregraphics.h @@ -0,0 +1,157 @@ +/* + * 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 . + */ + +#ifndef SDL2SOFTWAREGRAPHICS_H +#define SDL2SOFTWAREGRAPHICS_H + +#ifdef USE_SDL2 + +#include "render/graphics.h" + +#include "localconsts.h" + +class Image; +class ImageCollection; +class ImageVertexes; +class MapLayer; + +struct SDL_Surface; + +/** + * A central point of control for graphics. + */ +class SDL2SoftwareGraphics : public Graphics +{ + public: + /** + * Constructor. + */ + SDL2SoftwareGraphics(); + + A_DELETE_COPY(SDL2SoftwareGraphics) + + /** + * Destructor. + */ + virtual ~SDL2SoftwareGraphics(); + + void _beginDraw(); + + void _endDraw(); + + bool pushClipArea(gcn::Rectangle rect); + + void popClipArea(); + + 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 fillRectangle(const gcn::Rectangle &rect) override; + + void drawRectangle(const gcn::Rectangle &rect) override; + + void drawPoint(int x, int y) override; + + void drawLine(int x1, int y1, int x2, int y2) override; + + bool setVideoMode(const int w, const int h, const int bpp, + const bool fs, const bool hwaccel, + const bool resize, const bool noFrame); + + void setRendererFlags(const uint32_t flags) + { mRendererFlags = flags; } + + 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; + + void drawHLine(int x1, int y, int x2); + + void drawVLine(int x, int y1, int y2); + + uint32_t mRendererFlags; + SDL_Surface *mSurface; + uint32_t mOldPixel; + int mOldAlpha; +}; + +#endif // USE_SDL2 +#endif // SDL2SOFTWAREGRAPHICS_H diff --git a/src/resources/image.cpp b/src/resources/image.cpp index c289c90cd..1a327eae1 100644 --- a/src/resources/image.cpp +++ b/src/resources/image.cpp @@ -42,9 +42,7 @@ #include "utils/sdlcheckutils.h" #include -#ifndef USE_SDL2 #include -#endif #include "debug.h" @@ -388,7 +386,6 @@ Image* Image::SDLgetScaledImage(const int width, const int height) const Image* scaledImage = nullptr; -#ifndef USE_SDL2 if (mSDLSurface) { SDL_Surface *const scaledSurface = zoomSurface(mSDLSurface, @@ -404,7 +401,6 @@ Image* Image::SDLgetScaledImage(const int width, const int height) const MSDL_FreeSurface(scaledSurface); } } -#endif return scaledImage; } @@ -423,7 +419,11 @@ Image *Image::getSubImage(const int x, const int y, #endif #ifdef USE_SDL2 - return new SubImage(this, mTexture, x, y, width, height); + // +++ probably default sdl render is broken here + if (mode == RENDER_SOFTWARE) + return new SubImage(this, mSDLSurface, x, y, width, height); + else + return new SubImage(this, mTexture, x, y, width, height); #else return new SubImage(this, mSDLSurface, x, y, width, height); #endif diff --git a/src/resources/image.h b/src/resources/image.h index 7cdb1b5b3..664642e3a 100644 --- a/src/resources/image.h +++ b/src/resources/image.h @@ -61,6 +61,8 @@ class Image : public Resource friend class SDLImageHelper; friend class SurfaceGraphics; #ifdef USE_SDL2 + friend class SDL2SoftwareGraphics; + friend class SDL2SoftwareImageHelper; friend class SurfaceImageHelper; #endif friend class TestLauncher; diff --git a/src/resources/sdl2softwareimagehelper.cpp b/src/resources/sdl2softwareimagehelper.cpp new file mode 100644 index 000000000..3511b8298 --- /dev/null +++ b/src/resources/sdl2softwareimagehelper.cpp @@ -0,0 +1,184 @@ +/* + * 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 . + */ + +#ifdef USE_SDL2 + +#include "resources/sdl2softwareimagehelper.h" + +#include "resources/dye.h" +#include "resources/resourcemanager.h" + +#include "client.h" +#include "logger.h" +#include "main.h" + +#include "resources/image.h" + +#include "utils/sdlcheckutils.h" + +#include + +#include "debug.h" + +bool SDL2SoftwareImageHelper::mEnableAlphaCache = false; +SDL_Renderer *SDL2SoftwareImageHelper::mRenderer = nullptr; + +Image *SDL2SoftwareImageHelper::load(SDL_RWops *const rw, Dye const &dye) const +{ + SDL_Surface *const tmpImage = loadPng(rw); + if (!tmpImage) + { + logger->log("Error, image load failed: %s", IMG_GetError()); + return nullptr; + } + + SDL_PixelFormat rgba; + rgba.palette = nullptr; + rgba.BitsPerPixel = 32; + rgba.BytesPerPixel = 4; + +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + rgba.Rmask = 0x000000FF; + rgba.Gmask = 0x0000FF00; + rgba.Bmask = 0x00FF0000; + rgba.Amask = 0xFF000000; +#else + rgba.Rmask = 0xFF000000; + rgba.Gmask = 0x00FF0000; + rgba.Bmask = 0x0000FF00; + rgba.Amask = 0x000000FF; +#endif + + SDL_Surface *const surf = MSDL_ConvertSurface( + tmpImage, &rgba, SDL_SWSURFACE); + MSDL_FreeSurface(tmpImage); + + uint32_t *pixels = static_cast(surf->pixels); + const int type = dye.getType(); + + switch (type) + { + case 1: + { + const DyePalette *const pal = dye.getSPalete(); + if (pal) + pal->replaceSColor(pixels, surf->w * surf->h); + break; + } + case 2: + { + const DyePalette *const pal = dye.getAPalete(); + if (pal) + pal->replaceAColor(pixels, surf->w * surf->h); + break; + } + case 0: + default: + { + dye.normalDye(pixels, surf->w * surf->h); + break; + } + } + + Image *const image = load(surf); + MSDL_FreeSurface(surf); + return image; +} + +Image *SDL2SoftwareImageHelper::load(SDL_Surface *const tmpImage) const +{ + return _SDLload(tmpImage); +} + +Image *SDL2SoftwareImageHelper::createTextSurface(SDL_Surface *const tmpImage, + const int width A_UNUSED, + const int height A_UNUSED, + const float alpha) const +{ + if (!tmpImage) + return nullptr; + + Image *const img = _SDLload(tmpImage); + if (img) + img->setAlpha(alpha); + return img; +} + +SDL_Surface* SDL2SoftwareImageHelper::SDLDuplicateSurface(SDL_Surface *const + tmpImage) +{ + if (!tmpImage || !tmpImage->format) + return nullptr; + + return MSDL_ConvertSurface(tmpImage, tmpImage->format, SDL_SWSURFACE); +} + +Image *SDL2SoftwareImageHelper::_SDLload(SDL_Surface *tmpImage) const +{ + if (!tmpImage) + return nullptr; + +// SDL_Texture *const texture = SDL_CreateTextureFromSurface( +// mRenderer, tmpImage); +// if (!texture) +// return nullptr; +// SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); +// return new Image(texture, tmpImage->w, tmpImage->h); + SDL_Surface *image = convertTo32Bit(tmpImage); + return new Image(image, false, nullptr); +} + +RenderType SDL2SoftwareImageHelper::useOpenGL() const +{ + return RENDER_SOFTWARE; +} + +SDL_Surface *SDL2SoftwareImageHelper::create32BitSurface(int width, + int height) const +{ +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + const int rmask = 0xff000000; + const int gmask = 0x00ff0000; + const int bmask = 0x0000ff00; + const int amask = 0x000000ff; +#else + const int rmask = 0x000000ff; + const int gmask = 0x0000ff00; + const int bmask = 0x00ff0000; + const int amask = 0xff000000; +#endif + + return MSDL_CreateRGBSurface(SDL_SWSURFACE, + width, height, 32, rmask, gmask, bmask, amask); +} + +int SDL2SoftwareImageHelper::combineSurface(SDL_Surface *const src, + SDL_Rect *const srcrect, + SDL_Surface *const dst, + SDL_Rect *const dstrect) +{ + SDL_SetSurfaceBlendMode(src, SDL_BLENDMODE_BLEND); + SDL_BlitSurface(src, srcrect, dst, dstrect); + return 1; +} + +#endif // USE_SDL2 diff --git a/src/resources/sdl2softwareimagehelper.h b/src/resources/sdl2softwareimagehelper.h new file mode 100644 index 000000000..877ae9032 --- /dev/null +++ b/src/resources/sdl2softwareimagehelper.h @@ -0,0 +1,113 @@ +/* + * 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 . + */ + +#ifndef RESOURCES_SDL2SOFTWAREIMAGEHELPER_H +#define RESOURCES_SDL2SOFTWAREIMAGEHELPER_H + +#ifdef USE_SDL2 + +#include "localconsts.h" + +#include "resources/imagehelper.h" + +#include + +class Dye; +class Image; + +/** + * Defines a class for loading and storing images. + */ +class SDL2SoftwareImageHelper final : public ImageHelper +{ + friend class Image; + + public: + SDL2SoftwareImageHelper() + { } + + A_DELETE_COPY(SDL2SoftwareImageHelper) + + virtual ~SDL2SoftwareImageHelper() + { } + + /** + * Loads an image from an SDL_RWops structure and recolors it. + * + * @param rw The SDL_RWops to load the image from. + * @param dye The dye used to recolor the image. + * + * @return NULL if an error occurred, a valid pointer + * otherwise. + */ + Image *load(SDL_RWops *const rw, + Dye const &dye) const override A_WARN_UNUSED; + + /** + * Loads an image from an SDL surface. + */ + Image *load(SDL_Surface *const tmpImage) const override A_WARN_UNUSED; + + Image *createTextSurface(SDL_Surface *const tmpImage, + const int width, const int height, + const float alpha) + const override A_WARN_UNUSED; + + static void SDLSetEnableAlphaCache(const bool n) + { mEnableAlphaCache = n; } + + static bool SDLGetEnableAlphaCache() A_WARN_UNUSED + { return mEnableAlphaCache; } + + /** + * Tells if the image was loaded using OpenGL or SDL + * @return true if OpenGL, false if SDL. + */ + RenderType useOpenGL() const override A_WARN_UNUSED; + + static SDL_Surface* SDLDuplicateSurface(SDL_Surface *const tmpImage) + A_WARN_UNUSED; + + SDL_Surface *create32BitSurface(int width, int height) const override; + + static int combineSurface(SDL_Surface *const src, + SDL_Rect *const srcrect, + SDL_Surface *const dst, + SDL_Rect *const dstrect); + +#ifdef USE_SDL2 + static void setRenderer(SDL_Renderer *const renderer) + { mRenderer = renderer; } +#endif + + protected: + /** SDL_Surface to SDL_Surface Image loader */ + Image *_SDLload(SDL_Surface *tmpImage) const A_WARN_UNUSED; + + static bool mEnableAlphaCache; +#ifdef USE_SDL2 + static SDL_Renderer *mRenderer; +#endif +}; + +#endif // USE_SDL2 +#endif // RESOURCES_SDL2SOFTWAREIMAGEHELPER_H -- cgit v1.2.3-70-g09d2