2017-07-13 10:26:03 +02:00
|
|
|
/*
|
|
|
|
* SDL_Extensions.cpp, part of VCMI engine
|
|
|
|
*
|
|
|
|
* Authors: listed in file AUTHORS in main folder
|
|
|
|
*
|
|
|
|
* License: GNU General Public License v2.0 or later
|
|
|
|
* Full text of license available in license.txt file, in main folder
|
|
|
|
*
|
|
|
|
*/
|
2011-12-14 00:23:17 +03:00
|
|
|
#include "StdInc.h"
|
2007-06-06 21:26:28 +03:00
|
|
|
#include "SDL_Extensions.h"
|
2008-02-22 19:47:14 +02:00
|
|
|
|
2023-02-01 20:42:06 +02:00
|
|
|
#include "SDL_PixelAccess.h"
|
|
|
|
//
|
|
|
|
//#include "../CGameInfo.h"
|
|
|
|
//#include "../CMessage.h"
|
|
|
|
#include "../render/Graphics.h"
|
|
|
|
//#include "../CMT.h"
|
|
|
|
//
|
|
|
|
//#include <SDL_version.h>
|
2023-01-17 22:01:35 +02:00
|
|
|
#include <SDL_render.h>
|
|
|
|
#include <SDL_video.h>
|
|
|
|
#include <SDL_events.h>
|
2023-02-01 20:42:06 +02:00
|
|
|
//
|
|
|
|
//#ifdef VCMI_APPLE
|
|
|
|
//#include <dispatch/dispatch.h>
|
|
|
|
//#endif
|
|
|
|
//
|
|
|
|
//#ifdef VCMI_IOS
|
|
|
|
//#include "ios/utils.h"
|
|
|
|
//#endif
|
2022-07-27 09:58:41 +02:00
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
const SDL_Color Colors::YELLOW = { 229, 215, 123, SDL_ALPHA_OPAQUE };
|
|
|
|
const SDL_Color Colors::WHITE = { 255, 243, 222, SDL_ALPHA_OPAQUE };
|
|
|
|
const SDL_Color Colors::METALLIC_GOLD = { 173, 142, 66, SDL_ALPHA_OPAQUE };
|
|
|
|
const SDL_Color Colors::GREEN = { 0, 255, 0, SDL_ALPHA_OPAQUE };
|
|
|
|
const SDL_Color Colors::ORANGE = { 232, 184, 32, SDL_ALPHA_OPAQUE };
|
|
|
|
const SDL_Color Colors::BRIGHT_YELLOW = { 242, 226, 110, SDL_ALPHA_OPAQUE };
|
|
|
|
const SDL_Color Colors::DEFAULT_KEY_COLOR = {0, 255, 255, SDL_ALPHA_OPAQUE};
|
|
|
|
const SDL_Color Colors::RED = {255, 0, 0, SDL_ALPHA_OPAQUE};
|
|
|
|
const SDL_Color Colors::PURPLE = {255, 75, 125, SDL_ALPHA_OPAQUE};
|
|
|
|
const SDL_Color Colors::BLACK = {0, 0, 0, SDL_ALPHA_OPAQUE};
|
2023-01-18 16:54:53 +02:00
|
|
|
const SDL_Color Colors::TRANSPARENCY = {0, 0, 0, SDL_ALPHA_TRANSPARENT};
|
2023-01-17 22:01:35 +02:00
|
|
|
|
2023-01-18 15:50:52 +02:00
|
|
|
Rect CSDL_Ext::genRect(const int & hh, const int & ww, const int & xx, const int & yy)
|
|
|
|
{
|
|
|
|
Rect ret;
|
|
|
|
ret.h=hh;
|
|
|
|
ret.w=ww;
|
|
|
|
ret.x=xx;
|
|
|
|
ret.y=yy;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
Rect CSDL_Ext::fromSDL(const SDL_Rect & rect)
|
|
|
|
{
|
|
|
|
return Rect(Point(rect.x, rect.y), Point(rect.w, rect.h));
|
|
|
|
}
|
|
|
|
|
|
|
|
SDL_Rect CSDL_Ext::toSDL(const Rect & rect)
|
|
|
|
{
|
|
|
|
SDL_Rect result;
|
|
|
|
result.x = rect.x;
|
|
|
|
result.y = rect.y;
|
|
|
|
result.w = rect.w;
|
|
|
|
result.h = rect.h;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2023-01-30 00:12:43 +02:00
|
|
|
ColorRGBA CSDL_Ext::fromSDL(const SDL_Color & color)
|
|
|
|
{
|
|
|
|
return { color.r, color.g, color.b, color.a };
|
|
|
|
}
|
|
|
|
|
|
|
|
SDL_Color CSDL_Ext::toSDL(const ColorRGBA & color)
|
|
|
|
{
|
|
|
|
SDL_Color result;
|
|
|
|
result.r = color.r;
|
|
|
|
result.g = color.g;
|
|
|
|
result.b = color.b;
|
|
|
|
result.a = color.a;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::setColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors)
|
|
|
|
{
|
|
|
|
SDL_SetPaletteColors(surface->format->palette,colors,firstcolor,ncolors);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::warpMouse(int x, int y)
|
|
|
|
{
|
|
|
|
SDL_WarpMouseInWindow(mainWindow,x,y);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CSDL_Ext::isCtrlKeyDown()
|
|
|
|
{
|
|
|
|
return SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_LCTRL] || SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_RCTRL];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CSDL_Ext::isAltKeyDown()
|
|
|
|
{
|
|
|
|
return SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_LALT] || SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_RALT];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CSDL_Ext::isShiftKeyDown()
|
|
|
|
{
|
|
|
|
return SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_LSHIFT] || SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_RSHIFT];
|
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::setAlpha(SDL_Surface * bg, int value)
|
|
|
|
{
|
|
|
|
SDL_SetSurfaceAlphaMod(bg, value);
|
|
|
|
}
|
2012-11-11 15:23:31 +03:00
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::updateRect(SDL_Surface *surface, const Rect & rect )
|
2014-06-01 18:31:37 +03:00
|
|
|
{
|
2023-01-18 15:50:52 +02:00
|
|
|
SDL_Rect rectSDL = CSDL_Ext::toSDL(rect);
|
2023-01-17 22:01:35 +02:00
|
|
|
if(0 !=SDL_UpdateTexture(screenTexture, &rectSDL, surface->pixels, surface->pitch))
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->error("%sSDL_UpdateTexture %s", __FUNCTION__, SDL_GetError());
|
2014-06-01 18:31:37 +03:00
|
|
|
|
|
|
|
SDL_RenderClear(mainRenderer);
|
|
|
|
if(0 != SDL_RenderCopy(mainRenderer, screenTexture, NULL, NULL))
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->error("%sSDL_RenderCopy %s", __FUNCTION__, SDL_GetError());
|
2016-10-16 01:47:03 +02:00
|
|
|
SDL_RenderPresent(mainRenderer);
|
|
|
|
|
2014-06-01 18:31:37 +03:00
|
|
|
}
|
|
|
|
|
2007-09-30 19:16:00 +03:00
|
|
|
SDL_Surface * CSDL_Ext::newSurface(int w, int h, SDL_Surface * mod) //creates new surface, with flags/format same as in surface given
|
|
|
|
{
|
2018-07-25 00:36:48 +02:00
|
|
|
SDL_Surface * ret = SDL_CreateRGBSurface(0,w,h,mod->format->BitsPerPixel,mod->format->Rmask,mod->format->Gmask,mod->format->Bmask,mod->format->Amask);
|
2012-06-15 20:08:19 +03:00
|
|
|
if (mod->format->palette)
|
|
|
|
{
|
|
|
|
assert(ret->format->palette);
|
|
|
|
assert(ret->format->palette->ncolors == mod->format->palette->ncolors);
|
|
|
|
memcpy(ret->format->palette->colors, mod->format->palette->colors, mod->format->palette->ncolors * sizeof(SDL_Color));
|
|
|
|
}
|
|
|
|
return ret;
|
2007-09-30 19:16:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
SDL_Surface * CSDL_Ext::copySurface(SDL_Surface * mod) //returns copy of given surface
|
|
|
|
{
|
2008-02-09 16:44:32 +02:00
|
|
|
//return SDL_DisplayFormat(mod);
|
|
|
|
return SDL_ConvertSurface(mod, mod->format, mod->flags);
|
2007-09-30 19:16:00 +03:00
|
|
|
}
|
2009-06-26 18:41:19 +03:00
|
|
|
|
2012-05-18 20:35:46 +03:00
|
|
|
template<int bpp>
|
|
|
|
SDL_Surface * CSDL_Ext::createSurfaceWithBpp(int width, int height)
|
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
uint32_t rMask = 0, gMask = 0, bMask = 0, aMask = 0;
|
2012-05-18 20:35:46 +03:00
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
Channels::px<bpp>::r.set((uint8_t*)&rMask, 255);
|
|
|
|
Channels::px<bpp>::g.set((uint8_t*)&gMask, 255);
|
|
|
|
Channels::px<bpp>::b.set((uint8_t*)&bMask, 255);
|
|
|
|
Channels::px<bpp>::a.set((uint8_t*)&aMask, 255);
|
2012-05-18 20:35:46 +03:00
|
|
|
|
2018-07-25 00:36:48 +02:00
|
|
|
return SDL_CreateRGBSurface(0, width, height, bpp * 8, rMask, gMask, bMask, aMask);
|
2012-05-18 20:35:46 +03:00
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::blitAt(SDL_Surface * src, int x, int y, SDL_Surface * dst)
|
2007-06-19 18:25:42 +03:00
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
if(!dst)
|
|
|
|
dst = screen;
|
|
|
|
CSDL_Ext::blitSurface(src, dst, Point(x, y));
|
2007-06-19 18:25:42 +03:00
|
|
|
}
|
2009-02-08 17:39:26 +02:00
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::blitAt(SDL_Surface * src, const Rect & pos, SDL_Surface * dst)
|
2008-01-24 00:15:33 +02:00
|
|
|
{
|
2012-11-13 14:52:23 +03:00
|
|
|
if (src)
|
|
|
|
blitAt(src,pos.x,pos.y,dst);
|
2008-01-24 00:15:33 +02:00
|
|
|
}
|
2009-06-26 18:41:19 +03:00
|
|
|
|
2009-05-17 05:43:36 +03:00
|
|
|
// Vertical flip
|
2013-11-06 16:42:58 +03:00
|
|
|
SDL_Surface * CSDL_Ext::verticalFlip(SDL_Surface * toRot)
|
2007-06-06 21:26:28 +03:00
|
|
|
{
|
2008-02-06 15:50:40 +02:00
|
|
|
SDL_Surface * ret = SDL_ConvertSurface(toRot, toRot->format, toRot->flags);
|
2016-11-08 21:14:38 +02:00
|
|
|
|
|
|
|
SDL_LockSurface(ret);
|
|
|
|
SDL_LockSurface(toRot);
|
|
|
|
|
2009-05-17 05:43:36 +03:00
|
|
|
const int bpp = ret->format->BytesPerPixel;
|
|
|
|
|
2013-11-06 16:42:58 +03:00
|
|
|
char * src = reinterpret_cast<char *>(toRot->pixels);
|
|
|
|
char * dst = reinterpret_cast<char *>(ret->pixels);
|
2009-05-17 05:43:36 +03:00
|
|
|
|
2013-11-06 16:42:58 +03:00
|
|
|
for(int i=0; i<ret->h; i++)
|
2007-06-06 21:26:28 +03:00
|
|
|
{
|
2016-11-08 21:14:38 +02:00
|
|
|
//FIXME: optimization bugged
|
|
|
|
// if (bpp == 1)
|
|
|
|
// {
|
|
|
|
// // much faster for 8-bit surfaces (majority of our data)
|
|
|
|
// std::reverse_copy(src, src + toRot->pitch, dst);
|
|
|
|
// }
|
|
|
|
// else
|
|
|
|
// {
|
|
|
|
char * srcPxl = src;
|
|
|
|
char * dstPxl = dst + ret->w * bpp;
|
2013-11-06 16:42:58 +03:00
|
|
|
|
|
|
|
for(int j=0; j<ret->w; j++)
|
2007-06-06 21:26:28 +03:00
|
|
|
{
|
2013-11-06 16:42:58 +03:00
|
|
|
dstPxl -= bpp;
|
|
|
|
std::copy(srcPxl, srcPxl + bpp, dstPxl);
|
|
|
|
srcPxl += bpp;
|
2007-06-06 21:26:28 +03:00
|
|
|
}
|
2016-11-08 21:14:38 +02:00
|
|
|
// }
|
2013-11-06 16:42:58 +03:00
|
|
|
src += toRot->pitch;
|
|
|
|
dst += ret->pitch;
|
2007-06-06 21:26:28 +03:00
|
|
|
}
|
2016-11-08 21:14:38 +02:00
|
|
|
SDL_UnlockSurface(ret);
|
|
|
|
SDL_UnlockSurface(toRot);
|
2007-06-06 21:26:28 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-11-06 16:42:58 +03:00
|
|
|
// Horizontal flip
|
|
|
|
SDL_Surface * CSDL_Ext::horizontalFlip(SDL_Surface * toRot)
|
2007-06-06 21:26:28 +03:00
|
|
|
{
|
2008-02-06 15:50:40 +02:00
|
|
|
SDL_Surface * ret = SDL_ConvertSurface(toRot, toRot->format, toRot->flags);
|
2016-11-08 21:14:38 +02:00
|
|
|
SDL_LockSurface(ret);
|
|
|
|
SDL_LockSurface(toRot);
|
2013-11-06 16:42:58 +03:00
|
|
|
char * src = reinterpret_cast<char *>(toRot->pixels);
|
|
|
|
char * dst = reinterpret_cast<char *>(ret->pixels) + ret->h * ret->pitch;
|
|
|
|
|
|
|
|
for(int i=0; i<ret->h; i++)
|
2007-06-26 15:38:58 +03:00
|
|
|
{
|
2013-11-06 16:42:58 +03:00
|
|
|
dst -= ret->pitch;
|
|
|
|
std::copy(src, src + toRot->pitch, dst);
|
|
|
|
src += toRot->pitch;
|
2007-06-26 15:38:58 +03:00
|
|
|
}
|
2016-11-08 21:14:38 +02:00
|
|
|
SDL_UnlockSurface(ret);
|
|
|
|
SDL_UnlockSurface(toRot);
|
2007-06-06 21:26:28 +03:00
|
|
|
return ret;
|
2017-07-12 21:01:10 +02:00
|
|
|
}
|
2013-11-06 16:42:58 +03:00
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
uint32_t CSDL_Ext::getPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte)
|
2007-06-19 17:41:03 +03:00
|
|
|
{
|
2012-05-17 13:44:48 +03:00
|
|
|
int bpp = surface->format->BytesPerPixel;
|
|
|
|
/* Here p is the address to the pixel we want to retrieve */
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *p = (uint8_t *)surface->pixels + y * surface->pitch + x * bpp;
|
2007-06-19 17:41:03 +03:00
|
|
|
|
2012-05-17 13:44:48 +03:00
|
|
|
switch(bpp)
|
2008-12-23 15:59:03 +02:00
|
|
|
{
|
2012-05-17 13:44:48 +03:00
|
|
|
case 1:
|
2007-06-25 17:55:45 +03:00
|
|
|
if(colorByte)
|
2023-01-30 19:55:32 +02:00
|
|
|
return colorTouint32_t(surface->format->palette->colors+(*p));
|
2007-06-25 17:55:45 +03:00
|
|
|
else
|
|
|
|
return *p;
|
2007-06-19 17:41:03 +03:00
|
|
|
|
2012-05-17 13:44:48 +03:00
|
|
|
case 2:
|
2023-01-30 19:55:32 +02:00
|
|
|
return *(uint16_t *)p;
|
2007-06-19 17:41:03 +03:00
|
|
|
|
2012-05-17 13:44:48 +03:00
|
|
|
case 3:
|
|
|
|
return p[0] | p[1] << 8 | p[2] << 16;
|
|
|
|
|
|
|
|
case 4:
|
2023-01-30 19:55:32 +02:00
|
|
|
return *(uint32_t *)p;
|
2012-05-17 13:44:48 +03:00
|
|
|
|
|
|
|
default:
|
|
|
|
return 0; // shouldn't happen, but avoids warnings
|
|
|
|
}
|
2007-06-25 17:55:45 +03:00
|
|
|
}
|
|
|
|
|
2010-08-12 08:22:48 +03:00
|
|
|
template<int bpp>
|
2023-01-17 22:01:35 +02:00
|
|
|
int CSDL_Ext::blit8bppAlphaTo24bppT(const SDL_Surface * src, const Rect & srcRectInput, SDL_Surface * dst, const Point & dstPointInput)
|
2008-02-09 16:44:32 +02:00
|
|
|
{
|
2023-01-18 15:50:52 +02:00
|
|
|
SDL_Rect srcRectInstance = CSDL_Ext::toSDL(srcRectInput);
|
|
|
|
SDL_Rect dstRectInstance = CSDL_Ext::toSDL(Rect(dstPointInput, srcRectInput.dimensions()));
|
2023-01-17 22:01:35 +02:00
|
|
|
|
|
|
|
SDL_Rect * srcRect =&srcRectInstance;
|
|
|
|
SDL_Rect * dstRect =&dstRectInstance;
|
|
|
|
|
2016-12-05 02:17:03 +02:00
|
|
|
/* Make sure the surfaces aren't locked */
|
|
|
|
if ( ! src || ! dst )
|
|
|
|
{
|
|
|
|
SDL_SetError("SDL_UpperBlit: passed a nullptr surface");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( src->locked || dst->locked )
|
|
|
|
{
|
|
|
|
SDL_SetError("Surfaces must not be locked during blit");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (src->format->BytesPerPixel==1 && (bpp==3 || bpp==4 || bpp==2)) //everything's ok
|
2008-02-09 16:44:32 +02:00
|
|
|
{
|
2008-02-10 19:44:51 +02:00
|
|
|
SDL_Rect fulldst;
|
|
|
|
int srcx, srcy, w, h;
|
2008-02-09 16:44:32 +02:00
|
|
|
|
2013-06-26 14:18:27 +03:00
|
|
|
/* If the destination rectangle is nullptr, use the entire dest surface */
|
|
|
|
if ( dstRect == nullptr )
|
2008-12-23 15:59:03 +02:00
|
|
|
{
|
|
|
|
fulldst.x = fulldst.y = 0;
|
2008-02-10 19:44:51 +02:00
|
|
|
dstRect = &fulldst;
|
2008-02-09 16:44:32 +02:00
|
|
|
}
|
|
|
|
|
2008-02-10 19:44:51 +02:00
|
|
|
/* clip the source rectangle to the source surface */
|
2009-02-08 17:39:26 +02:00
|
|
|
if(srcRect)
|
2008-11-30 02:15:38 +02:00
|
|
|
{
|
|
|
|
int maxw, maxh;
|
2008-08-02 18:08:03 +03:00
|
|
|
|
2008-02-10 19:44:51 +02:00
|
|
|
srcx = srcRect->x;
|
|
|
|
w = srcRect->w;
|
2008-12-23 15:59:03 +02:00
|
|
|
if(srcx < 0)
|
|
|
|
{
|
2009-05-28 05:58:29 +03:00
|
|
|
w += srcx;
|
2008-02-10 19:44:51 +02:00
|
|
|
dstRect->x -= srcx;
|
|
|
|
srcx = 0;
|
2008-02-09 16:44:32 +02:00
|
|
|
}
|
2008-02-10 19:44:51 +02:00
|
|
|
maxw = src->w - srcx;
|
|
|
|
if(maxw < w)
|
|
|
|
w = maxw;
|
|
|
|
|
|
|
|
srcy = srcRect->y;
|
|
|
|
h = srcRect->h;
|
2008-12-23 15:59:03 +02:00
|
|
|
if(srcy < 0)
|
|
|
|
{
|
2008-02-10 19:44:51 +02:00
|
|
|
h += srcy;
|
|
|
|
dstRect->y -= srcy;
|
|
|
|
srcy = 0;
|
2008-02-09 16:44:32 +02:00
|
|
|
}
|
2008-02-10 19:44:51 +02:00
|
|
|
maxh = src->h - srcy;
|
|
|
|
if(maxh < h)
|
|
|
|
h = maxh;
|
2008-08-02 18:08:03 +03:00
|
|
|
|
2009-02-08 17:39:26 +02:00
|
|
|
}
|
|
|
|
else
|
2008-11-30 02:15:38 +02:00
|
|
|
{
|
2009-10-01 23:00:21 +03:00
|
|
|
srcx = srcy = 0;
|
2008-02-10 19:44:51 +02:00
|
|
|
w = src->w;
|
|
|
|
h = src->h;
|
2008-02-09 16:44:32 +02:00
|
|
|
}
|
|
|
|
|
2008-02-10 19:44:51 +02:00
|
|
|
/* clip the destination rectangle against the clip rectangle */
|
2008-02-09 16:44:32 +02:00
|
|
|
{
|
2010-08-05 14:02:18 +03:00
|
|
|
SDL_Rect *clip = &dst->clip_rect;
|
2008-02-10 19:44:51 +02:00
|
|
|
int dx, dy;
|
|
|
|
|
|
|
|
dx = clip->x - dstRect->x;
|
2008-12-23 15:59:03 +02:00
|
|
|
if(dx > 0)
|
|
|
|
{
|
2008-02-10 19:44:51 +02:00
|
|
|
w -= dx;
|
|
|
|
dstRect->x += dx;
|
|
|
|
srcx += dx;
|
|
|
|
}
|
|
|
|
dx = dstRect->x + w - clip->x - clip->w;
|
|
|
|
if(dx > 0)
|
|
|
|
w -= dx;
|
|
|
|
|
|
|
|
dy = clip->y - dstRect->y;
|
2008-12-23 15:59:03 +02:00
|
|
|
if(dy > 0)
|
|
|
|
{
|
2008-02-10 19:44:51 +02:00
|
|
|
h -= dy;
|
|
|
|
dstRect->y += dy;
|
|
|
|
srcy += dy;
|
|
|
|
}
|
|
|
|
dy = dstRect->y + h - clip->y - clip->h;
|
|
|
|
if(dy > 0)
|
|
|
|
h -= dy;
|
2008-02-09 16:44:32 +02:00
|
|
|
}
|
|
|
|
|
2008-02-10 19:44:51 +02:00
|
|
|
if(w > 0 && h > 0)
|
2008-02-09 16:44:32 +02:00
|
|
|
{
|
2009-05-23 23:13:09 +03:00
|
|
|
dstRect->w = w;
|
|
|
|
dstRect->h = h;
|
2008-02-09 16:44:32 +02:00
|
|
|
|
2008-08-07 15:29:53 +03:00
|
|
|
if(SDL_LockSurface(dst))
|
|
|
|
return -1; //if we cannot lock the surface
|
|
|
|
|
2009-05-23 23:13:09 +03:00
|
|
|
const SDL_Color *colors = src->format->palette->colors;
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *colory = (uint8_t*)src->pixels + srcy*src->pitch + srcx;
|
|
|
|
uint8_t *py = (uint8_t*)dst->pixels + dstRect->y*dst->pitch + dstRect->x*bpp;
|
2009-05-23 23:13:09 +03:00
|
|
|
|
2010-08-12 08:22:48 +03:00
|
|
|
for(int y=h; y; y--, colory+=src->pitch, py+=dst->pitch)
|
2010-08-05 14:02:18 +03:00
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *color = colory;
|
|
|
|
uint8_t *p = py;
|
2010-08-05 14:02:18 +03:00
|
|
|
|
2010-08-12 08:22:48 +03:00
|
|
|
for(int x = w; x; x--)
|
2010-08-05 14:02:18 +03:00
|
|
|
{
|
2010-08-12 08:22:48 +03:00
|
|
|
const SDL_Color &tbc = colors[*color++]; //color to blit
|
2014-05-21 19:04:34 +03:00
|
|
|
ColorPutter<bpp, +1>::PutColorAlphaSwitch(p, tbc.r, tbc.g, tbc.b, tbc.a);
|
2010-08-05 14:02:18 +03:00
|
|
|
}
|
|
|
|
}
|
2008-08-07 15:29:53 +03:00
|
|
|
SDL_UnlockSurface(dst);
|
2008-02-09 16:44:32 +02:00
|
|
|
}
|
|
|
|
}
|
2008-02-10 19:44:51 +02:00
|
|
|
return 0;
|
2007-06-27 23:17:58 +03:00
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
int CSDL_Ext::blit8bppAlphaTo24bpp(const SDL_Surface * src, const Rect & srcRect, SDL_Surface * dst, const Point & dstPoint)
|
2010-08-12 08:22:48 +03:00
|
|
|
{
|
|
|
|
switch(dst->format->BytesPerPixel)
|
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
case 2: return blit8bppAlphaTo24bppT<2>(src, srcRect, dst, dstPoint);
|
|
|
|
case 3: return blit8bppAlphaTo24bppT<3>(src, srcRect, dst, dstPoint);
|
|
|
|
case 4: return blit8bppAlphaTo24bppT<4>(src, srcRect, dst, dstPoint);
|
2010-08-12 08:22:48 +03:00
|
|
|
default:
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->error("%d bpp is not supported!", (int)dst->format->BitsPerPixel);
|
2010-08-12 08:22:48 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
uint32_t CSDL_Ext::colorTouint32_t(const SDL_Color * color)
|
2007-06-25 17:55:45 +03:00
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
uint32_t ret = 0;
|
2014-05-21 19:04:34 +03:00
|
|
|
ret+=color->a;
|
2008-01-30 16:19:35 +02:00
|
|
|
ret<<=8; //*=256
|
2007-06-25 17:55:45 +03:00
|
|
|
ret+=color->b;
|
2008-01-30 16:19:35 +02:00
|
|
|
ret<<=8; //*=256
|
2007-06-25 17:55:45 +03:00
|
|
|
ret+=color->g;
|
2008-01-30 16:19:35 +02:00
|
|
|
ret<<=8; //*=256
|
2007-06-25 17:55:45 +03:00
|
|
|
ret+=color->r;
|
|
|
|
return ret;
|
|
|
|
}
|
2007-07-12 14:41:31 +03:00
|
|
|
|
|
|
|
void CSDL_Ext::update(SDL_Surface * what)
|
|
|
|
{
|
2014-06-01 18:31:37 +03:00
|
|
|
if(!what)
|
|
|
|
return;
|
2014-06-01 20:09:47 +03:00
|
|
|
if(0 !=SDL_UpdateTexture(screenTexture, nullptr, what->pixels, what->pitch))
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->error("%s SDL_UpdateTexture %s", __FUNCTION__, SDL_GetError());
|
2007-07-12 14:41:31 +03:00
|
|
|
}
|
2022-11-15 21:42:16 +02:00
|
|
|
|
|
|
|
static void drawLineX(SDL_Surface * sur, int x1, int y1, int x2, int y2, const SDL_Color & color1, const SDL_Color & color2)
|
|
|
|
{
|
|
|
|
for(int x = x1; x <= x2; x++)
|
|
|
|
{
|
|
|
|
float f = float(x - x1) / float(x2 - x1);
|
2022-12-15 23:24:03 +02:00
|
|
|
int y = vstd::lerp(y1, y2, f);
|
2022-11-15 21:42:16 +02:00
|
|
|
|
2022-12-15 23:24:03 +02:00
|
|
|
uint8_t r = vstd::lerp(color1.r, color2.r, f);
|
|
|
|
uint8_t g = vstd::lerp(color1.g, color2.g, f);
|
|
|
|
uint8_t b = vstd::lerp(color1.b, color2.b, f);
|
|
|
|
uint8_t a = vstd::lerp(color1.a, color2.a, f);
|
2022-11-15 21:42:16 +02:00
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *p = CSDL_Ext::getPxPtr(sur, x, y);
|
2022-11-15 21:42:16 +02:00
|
|
|
ColorPutter<4, 0>::PutColor(p, r,g,b,a);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drawLineY(SDL_Surface * sur, int x1, int y1, int x2, int y2, const SDL_Color & color1, const SDL_Color & color2)
|
|
|
|
{
|
|
|
|
for(int y = y1; y <= y2; y++)
|
|
|
|
{
|
|
|
|
float f = float(y - y1) / float(y2 - y1);
|
2022-12-15 23:24:03 +02:00
|
|
|
int x = vstd::lerp(x1, x2, f);
|
2022-11-15 21:42:16 +02:00
|
|
|
|
2022-12-15 23:24:03 +02:00
|
|
|
uint8_t r = vstd::lerp(color1.r, color2.r, f);
|
|
|
|
uint8_t g = vstd::lerp(color1.g, color2.g, f);
|
|
|
|
uint8_t b = vstd::lerp(color1.b, color2.b, f);
|
|
|
|
uint8_t a = vstd::lerp(color1.a, color2.a, f);
|
2022-11-15 21:42:16 +02:00
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *p = CSDL_Ext::getPxPtr(sur, x, y);
|
2022-11-15 21:42:16 +02:00
|
|
|
ColorPutter<4, 0>::PutColor(p, r,g,b,a);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::drawLine(SDL_Surface * sur, int x1, int y1, int x2, int y2, const SDL_Color & color1, const SDL_Color & color2)
|
|
|
|
{
|
|
|
|
int width = std::abs(x1-x2);
|
|
|
|
int height = std::abs(y1-y2);
|
|
|
|
|
|
|
|
if ( width == 0 && height == 0)
|
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *p = CSDL_Ext::getPxPtr(sur, x1, y1);
|
2022-11-15 21:42:16 +02:00
|
|
|
ColorPutter<4, 0>::PutColorAlpha(p, color1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (width > height)
|
|
|
|
{
|
|
|
|
if ( x1 < x2)
|
|
|
|
drawLineX(sur, x1,y1,x2,y2, color1, color2);
|
|
|
|
else
|
2022-11-16 12:28:07 +02:00
|
|
|
drawLineX(sur, x2,y2,x1,y1, color2, color1);
|
2022-11-15 21:42:16 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ( y1 < y2)
|
|
|
|
drawLineY(sur, x1,y1,x2,y2, color1, color2);
|
|
|
|
else
|
2022-11-16 12:28:07 +02:00
|
|
|
drawLineY(sur, x2,y2,x1,y1, color2, color1);
|
2022-11-15 21:42:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::drawBorder(SDL_Surface * sur, int x, int y, int w, int h, const SDL_Color &color)
|
2008-04-04 20:30:53 +03:00
|
|
|
{
|
2011-04-29 03:50:54 +03:00
|
|
|
for(int i = 0; i < w; i++)
|
2008-04-04 20:30:53 +03:00
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur,x+i,y,color.r,color.g,color.b);
|
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur,x+i,y+h-1,color.r,color.g,color.b);
|
2008-04-04 20:30:53 +03:00
|
|
|
}
|
2011-04-29 03:50:54 +03:00
|
|
|
for(int i = 0; i < h; i++)
|
2008-04-04 20:30:53 +03:00
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur,x,y+i,color.r,color.g,color.b);
|
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur,x+w-1,y+i,color.r,color.g,color.b);
|
2008-04-04 20:30:53 +03:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 15:47:40 +03:00
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::drawBorder( SDL_Surface * sur, const Rect &r, const SDL_Color &color )
|
2009-09-20 15:47:40 +03:00
|
|
|
{
|
|
|
|
drawBorder(sur, r.x, r.y, r.w, r.h, color);
|
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::drawDashedBorder(SDL_Surface * sur, const Rect &r, const SDL_Color &color)
|
2010-08-05 14:02:18 +03:00
|
|
|
{
|
|
|
|
const int y1 = r.y, y2 = r.y + r.h-1;
|
|
|
|
for (int i=0; i<r.w; i++)
|
|
|
|
{
|
|
|
|
const int x = r.x + i;
|
|
|
|
if (i%4 || (i==0))
|
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur, x, y1, color.r, color.g, color.b);
|
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur, x, y2, color.r, color.g, color.b);
|
2010-08-05 14:02:18 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const int x1 = r.x, x2 = r.x + r.w-1;
|
|
|
|
for (int i=0; i<r.h; i++)
|
|
|
|
{
|
|
|
|
const int y = r.y + i;
|
|
|
|
if ((i%4) || (i==0))
|
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur, x1, y, color.r, color.g, color.b);
|
|
|
|
CSDL_Ext::putPixelWithoutRefreshIfInSurf(sur, x2, y, color.r, color.g, color.b);
|
2010-08-05 14:02:18 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-03 20:06:03 +03:00
|
|
|
void CSDL_Ext::setPlayerColor(SDL_Surface * sur, PlayerColor player)
|
2007-07-16 13:03:54 +03:00
|
|
|
{
|
2013-03-03 20:06:03 +03:00
|
|
|
if(player==PlayerColor::UNFLAGGABLE)
|
2007-10-07 19:01:53 +03:00
|
|
|
return;
|
2007-07-16 13:03:54 +03:00
|
|
|
if(sur->format->BitsPerPixel==8)
|
|
|
|
{
|
2013-03-03 20:06:03 +03:00
|
|
|
SDL_Color *color = (player == PlayerColor::NEUTRAL
|
2010-03-21 00:17:19 +02:00
|
|
|
? graphics->neutralColor
|
2013-03-03 20:06:03 +03:00
|
|
|
: &graphics->playerColors[player.getNum()]);
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::setColors(sur, color, 5, 1);
|
2007-07-16 13:03:54 +03:00
|
|
|
}
|
2010-03-21 00:17:19 +02:00
|
|
|
else
|
2017-08-10 18:39:27 +02:00
|
|
|
logGlobal->warn("Warning, setPlayerColor called on not 8bpp surface!");
|
2007-08-06 07:03:34 +03:00
|
|
|
}
|
2007-08-17 20:42:21 +03:00
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::TColorPutter CSDL_Ext::getPutterFor(SDL_Surface * const &dest, int incrementing)
|
2010-08-05 14:02:18 +03:00
|
|
|
{
|
|
|
|
#define CASE_BPP(BytesPerPixel) \
|
|
|
|
case BytesPerPixel: \
|
2010-08-12 08:22:48 +03:00
|
|
|
if(incrementing > 0) \
|
|
|
|
return ColorPutter<BytesPerPixel, 1>::PutColor; \
|
|
|
|
else if(incrementing == 0) \
|
|
|
|
return ColorPutter<BytesPerPixel, 0>::PutColor; \
|
2010-08-05 14:02:18 +03:00
|
|
|
else \
|
2010-08-12 08:22:48 +03:00
|
|
|
return ColorPutter<BytesPerPixel, -1>::PutColor;\
|
2010-08-05 14:02:18 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
switch(dest->format->BytesPerPixel)
|
|
|
|
{
|
|
|
|
CASE_BPP(2)
|
|
|
|
CASE_BPP(3)
|
|
|
|
CASE_BPP(4)
|
|
|
|
default:
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->error("%d bpp is not supported!", (int)dest->format->BitsPerPixel);
|
2013-06-26 14:18:27 +03:00
|
|
|
return nullptr;
|
2010-08-05 14:02:18 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::TColorPutterAlpha CSDL_Ext::getPutterAlphaFor(SDL_Surface * const &dest, int incrementing)
|
2010-08-12 08:22:48 +03:00
|
|
|
{
|
|
|
|
switch(dest->format->BytesPerPixel)
|
|
|
|
{
|
|
|
|
CASE_BPP(2)
|
|
|
|
CASE_BPP(3)
|
|
|
|
CASE_BPP(4)
|
|
|
|
default:
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->error("%d bpp is not supported!", (int)dest->format->BitsPerPixel);
|
2013-06-26 14:18:27 +03:00
|
|
|
return nullptr;
|
2010-08-12 08:22:48 +03:00
|
|
|
}
|
|
|
|
#undef CASE_BPP
|
|
|
|
}
|
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t * CSDL_Ext::getPxPtr(const SDL_Surface * const &srf, const int x, const int y)
|
2010-08-05 14:02:18 +03:00
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
return (uint8_t *)srf->pixels + y * srf->pitch + x * srf->format->BytesPerPixel;
|
2010-08-05 14:02:18 +03:00
|
|
|
}
|
|
|
|
|
2007-09-14 16:11:10 +03:00
|
|
|
std::string CSDL_Ext::processStr(std::string str, std::vector<std::string> & tor)
|
|
|
|
{
|
2008-12-21 21:17:35 +02:00
|
|
|
for (size_t i=0; (i<tor.size())&&(boost::find_first(str,"%s")); ++i)
|
2007-09-14 16:11:10 +03:00
|
|
|
{
|
|
|
|
boost::replace_first(str,"%s",tor[i]);
|
|
|
|
}
|
|
|
|
return str;
|
2008-02-06 15:50:40 +02:00
|
|
|
}
|
|
|
|
|
2023-01-27 00:27:06 +02:00
|
|
|
bool CSDL_Ext::isTransparent( SDL_Surface * srf, const Point & position )
|
|
|
|
{
|
|
|
|
return isTransparent(srf, position.x, position.y);
|
|
|
|
}
|
|
|
|
|
2010-02-18 14:34:44 +02:00
|
|
|
bool CSDL_Ext::isTransparent( SDL_Surface * srf, int x, int y )
|
|
|
|
{
|
2012-01-19 17:33:22 +03:00
|
|
|
if (x < 0 || y < 0 || x >= srf->w || y >= srf->h)
|
|
|
|
return true;
|
|
|
|
|
2013-04-03 19:28:50 +03:00
|
|
|
SDL_Color color;
|
2016-10-16 01:47:03 +02:00
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
SDL_GetRGBA(CSDL_Ext::getPixel(srf, x, y), srf->format, &color.r, &color.g, &color.b, &color.a);
|
2013-04-03 19:28:50 +03:00
|
|
|
|
2022-12-16 16:23:07 +02:00
|
|
|
bool pixelTransparent = color.a < 128;
|
|
|
|
bool pixelCyan = (color.r == 0 && color.g == 255 && color.b == 255);
|
|
|
|
|
|
|
|
return pixelTransparent || pixelCyan;
|
2010-02-18 14:34:44 +02:00
|
|
|
}
|
|
|
|
|
2010-07-15 20:13:17 +03:00
|
|
|
void CSDL_Ext::VflipSurf(SDL_Surface * surf)
|
|
|
|
{
|
|
|
|
char buf[4]; //buffer
|
|
|
|
int bpp = surf->format->BytesPerPixel;
|
|
|
|
for (int y=0; y<surf->h; ++y)
|
|
|
|
{
|
|
|
|
char * base = (char*)surf->pixels + y * surf->pitch;
|
|
|
|
for (int x=0; x<surf->w/2; ++x)
|
|
|
|
{
|
|
|
|
memcpy(buf, base + x * bpp, bpp);
|
|
|
|
memcpy(base + x * bpp, base + (surf->w - x - 1) * bpp, bpp);
|
|
|
|
memcpy(base + (surf->w - x - 1) * bpp, buf, bpp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
void CSDL_Ext::putPixelWithoutRefresh(SDL_Surface *ekran, const int & x, const int & y, const uint8_t & R, const uint8_t & G, const uint8_t & B, uint8_t A)
|
2010-08-05 14:02:18 +03:00
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *p = getPxPtr(ekran, x, y);
|
2010-08-05 14:02:18 +03:00
|
|
|
getPutterFor(ekran, false)(p, R, G, B);
|
2012-05-19 19:22:34 +03:00
|
|
|
|
|
|
|
switch(ekran->format->BytesPerPixel)
|
|
|
|
{
|
|
|
|
case 2: Channels::px<2>::a.set(p, A); break;
|
|
|
|
case 3: Channels::px<3>::a.set(p, A); break;
|
|
|
|
case 4: Channels::px<4>::a.set(p, A); break;
|
|
|
|
}
|
2010-08-05 14:02:18 +03:00
|
|
|
}
|
|
|
|
|
2023-01-30 19:55:32 +02:00
|
|
|
void CSDL_Ext::putPixelWithoutRefreshIfInSurf(SDL_Surface *ekran, const int & x, const int & y, const uint8_t & R, const uint8_t & G, const uint8_t & B, uint8_t A)
|
2010-08-05 14:02:18 +03:00
|
|
|
{
|
2012-06-13 16:04:06 +03:00
|
|
|
const SDL_Rect & rect = ekran->clip_rect;
|
|
|
|
|
|
|
|
if(x >= rect.x && x < rect.w + rect.x
|
|
|
|
&& y >= rect.y && y < rect.h + rect.y)
|
2023-01-17 22:01:35 +02:00
|
|
|
CSDL_Ext::putPixelWithoutRefresh(ekran, x, y, R, G, B, A);
|
2010-08-05 14:02:18 +03:00
|
|
|
}
|
|
|
|
|
2012-05-17 13:44:48 +03:00
|
|
|
template<int bpp>
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::applyEffectBpp(SDL_Surface * surf, const Rect & rect, int mode )
|
2010-08-17 15:48:34 +03:00
|
|
|
{
|
|
|
|
switch(mode)
|
|
|
|
{
|
|
|
|
case 0: //sepia
|
|
|
|
{
|
|
|
|
const int sepiaDepth = 20;
|
|
|
|
const int sepiaIntensity = 30;
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
for(int xp = rect.x; xp < rect.x + rect.w; ++xp)
|
2010-08-17 15:48:34 +03:00
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
for(int yp = rect.y; yp < rect.y + rect.h; ++yp)
|
2010-08-17 15:48:34 +03:00
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t * pixel = (ui8*)surf->pixels + yp * surf->pitch + xp * surf->format->BytesPerPixel;
|
2012-05-17 13:44:48 +03:00
|
|
|
int r = Channels::px<bpp>::r.get(pixel);
|
|
|
|
int g = Channels::px<bpp>::g.get(pixel);
|
|
|
|
int b = Channels::px<bpp>::b.get(pixel);
|
2020-10-01 10:38:06 +02:00
|
|
|
int gray = static_cast<int>(0.299 * r + 0.587 * g + 0.114 * b);
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2012-05-17 13:44:48 +03:00
|
|
|
r = g = b = gray;
|
2012-02-16 20:10:58 +03:00
|
|
|
r = r + (sepiaDepth * 2);
|
|
|
|
g = g + sepiaDepth;
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2012-02-16 20:10:58 +03:00
|
|
|
if (r>255) r=255;
|
|
|
|
if (g>255) g=255;
|
|
|
|
if (b>255) b=255;
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2012-02-16 20:10:58 +03:00
|
|
|
// Darken blue color to increase sepia effect
|
|
|
|
b -= sepiaIntensity;
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2012-02-16 20:10:58 +03:00
|
|
|
// normalize if out of bounds
|
|
|
|
if (b<0) b=0;
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2012-05-17 13:44:48 +03:00
|
|
|
Channels::px<bpp>::r.set(pixel, r);
|
|
|
|
Channels::px<bpp>::g.set(pixel, g);
|
|
|
|
Channels::px<bpp>::b.set(pixel, b);
|
2010-08-17 15:48:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1: //grayscale
|
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
for(int xp = rect.x; xp < rect.x + rect.w; ++xp)
|
2010-08-17 15:48:34 +03:00
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
for(int yp = rect.y; yp < rect.y + rect.h; ++yp)
|
2010-08-17 15:48:34 +03:00
|
|
|
{
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t * pixel = (ui8*)surf->pixels + yp * surf->pitch + xp * surf->format->BytesPerPixel;
|
2012-05-17 13:44:48 +03:00
|
|
|
|
|
|
|
int r = Channels::px<bpp>::r.get(pixel);
|
|
|
|
int g = Channels::px<bpp>::g.get(pixel);
|
|
|
|
int b = Channels::px<bpp>::b.get(pixel);
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2020-10-01 10:38:06 +02:00
|
|
|
int gray = static_cast<int>(0.299 * r + 0.587 * g + 0.114 *b);
|
2012-05-17 13:44:48 +03:00
|
|
|
vstd::amax(gray, 255);
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2012-05-17 13:44:48 +03:00
|
|
|
Channels::px<bpp>::r.set(pixel, gray);
|
|
|
|
Channels::px<bpp>::g.set(pixel, gray);
|
|
|
|
Channels::px<bpp>::b.set(pixel, gray);
|
2010-08-17 15:48:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2012-05-20 00:38:01 +03:00
|
|
|
throw std::runtime_error("Unsupported effect!");
|
2010-08-17 15:48:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::applyEffect( SDL_Surface * surf, const Rect & rect, int mode )
|
2012-05-17 13:44:48 +03:00
|
|
|
{
|
|
|
|
switch(surf->format->BytesPerPixel)
|
|
|
|
{
|
|
|
|
case 2: applyEffectBpp<2>(surf, rect, mode); break;
|
|
|
|
case 3: applyEffectBpp<3>(surf, rect, mode); break;
|
|
|
|
case 4: applyEffectBpp<4>(surf, rect, mode); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-15 20:08:19 +03:00
|
|
|
template<int bpp>
|
|
|
|
void scaleSurfaceFastInternal(SDL_Surface *surf, SDL_Surface *ret)
|
|
|
|
{
|
|
|
|
const float factorX = float(surf->w) / float(ret->w),
|
2012-11-11 15:23:31 +03:00
|
|
|
factorY = float(surf->h) / float(ret->h);
|
2012-06-15 20:08:19 +03:00
|
|
|
|
|
|
|
for(int y = 0; y < ret->h; y++)
|
|
|
|
{
|
|
|
|
for(int x = 0; x < ret->w; x++)
|
|
|
|
{
|
|
|
|
//coordinates we want to calculate
|
2020-10-01 10:38:06 +02:00
|
|
|
int origX = static_cast<int>(floor(factorX * x)),
|
|
|
|
origY = static_cast<int>(floor(factorY * y));
|
2012-06-15 20:08:19 +03:00
|
|
|
|
|
|
|
// Get pointers to source pixels
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *srcPtr = (uint8_t*)surf->pixels + origY * surf->pitch + origX * bpp;
|
|
|
|
uint8_t *destPtr = (uint8_t*)ret->pixels + y * ret->pitch + x * bpp;
|
2012-06-15 20:08:19 +03:00
|
|
|
|
|
|
|
memcpy(destPtr, srcPtr, bpp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SDL_Surface * CSDL_Ext::scaleSurfaceFast(SDL_Surface *surf, int width, int height)
|
|
|
|
{
|
|
|
|
if (!surf || !width || !height)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
//Same size? return copy - this should more be faster
|
|
|
|
if (width == surf->w && height == surf->h)
|
|
|
|
return copySurface(surf);
|
|
|
|
|
|
|
|
SDL_Surface *ret = newSurface(width, height, surf);
|
|
|
|
|
|
|
|
switch(surf->format->BytesPerPixel)
|
|
|
|
{
|
|
|
|
case 1: scaleSurfaceFastInternal<1>(surf, ret); break;
|
|
|
|
case 2: scaleSurfaceFastInternal<2>(surf, ret); break;
|
|
|
|
case 3: scaleSurfaceFastInternal<3>(surf, ret); break;
|
|
|
|
case 4: scaleSurfaceFastInternal<4>(surf, ret); break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-20 00:38:01 +03:00
|
|
|
template<int bpp>
|
|
|
|
void scaleSurfaceInternal(SDL_Surface *surf, SDL_Surface *ret)
|
|
|
|
{
|
|
|
|
const float factorX = float(surf->w - 1) / float(ret->w),
|
2012-11-11 15:23:31 +03:00
|
|
|
factorY = float(surf->h - 1) / float(ret->h);
|
2012-05-20 00:38:01 +03:00
|
|
|
|
|
|
|
for(int y = 0; y < ret->h; y++)
|
|
|
|
{
|
|
|
|
for(int x = 0; x < ret->w; x++)
|
|
|
|
{
|
|
|
|
//coordinates we want to interpolate
|
2012-06-15 20:08:19 +03:00
|
|
|
float origX = factorX * x,
|
2012-11-11 15:23:31 +03:00
|
|
|
origY = factorY * y;
|
2012-05-20 00:38:01 +03:00
|
|
|
|
|
|
|
float x1 = floor(origX), x2 = floor(origX+1),
|
2012-11-11 15:23:31 +03:00
|
|
|
y1 = floor(origY), y2 = floor(origY+1);
|
2012-05-20 14:03:21 +03:00
|
|
|
//assert( x1 >= 0 && y1 >= 0 && x2 < surf->w && y2 < surf->h);//All pixels are in range
|
2012-05-20 00:38:01 +03:00
|
|
|
|
|
|
|
// Calculate weights of each source pixel
|
|
|
|
float w11 = ((origX - x1) * (origY - y1));
|
|
|
|
float w12 = ((origX - x1) * (y2 - origY));
|
|
|
|
float w21 = ((x2 - origX) * (origY - y1));
|
|
|
|
float w22 = ((x2 - origX) * (y2 - origY));
|
2012-05-20 14:03:21 +03:00
|
|
|
//assert( w11 + w12 + w21 + w22 > 0.99 && w11 + w12 + w21 + w22 < 1.01);//total weight is ~1.0
|
2012-05-20 00:38:01 +03:00
|
|
|
|
|
|
|
// Get pointers to source pixels
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *p11 = (uint8_t*)surf->pixels + int(y1) * surf->pitch + int(x1) * bpp;
|
|
|
|
uint8_t *p12 = p11 + bpp;
|
|
|
|
uint8_t *p21 = p11 + surf->pitch;
|
|
|
|
uint8_t *p22 = p21 + bpp;
|
2012-05-20 00:38:01 +03:00
|
|
|
// Calculate resulting channels
|
|
|
|
#define PX(X, PTR) Channels::px<bpp>::X.get(PTR)
|
2020-10-01 10:38:06 +02:00
|
|
|
int resR = static_cast<int>(PX(r, p11) * w11 + PX(r, p12) * w12 + PX(r, p21) * w21 + PX(r, p22) * w22);
|
|
|
|
int resG = static_cast<int>(PX(g, p11) * w11 + PX(g, p12) * w12 + PX(g, p21) * w21 + PX(g, p22) * w22);
|
|
|
|
int resB = static_cast<int>(PX(b, p11) * w11 + PX(b, p12) * w12 + PX(b, p21) * w21 + PX(b, p22) * w22);
|
|
|
|
int resA = static_cast<int>(PX(a, p11) * w11 + PX(a, p12) * w12 + PX(a, p21) * w21 + PX(a, p22) * w22);
|
2012-05-20 14:03:21 +03:00
|
|
|
//assert(resR < 256 && resG < 256 && resB < 256 && resA < 256);
|
2012-05-20 00:38:01 +03:00
|
|
|
#undef PX
|
2023-01-30 19:55:32 +02:00
|
|
|
uint8_t *dest = (uint8_t*)ret->pixels + y * ret->pitch + x * bpp;
|
2012-05-20 00:38:01 +03:00
|
|
|
Channels::px<bpp>::r.set(dest, resR);
|
|
|
|
Channels::px<bpp>::g.set(dest, resG);
|
|
|
|
Channels::px<bpp>::b.set(dest, resB);
|
|
|
|
Channels::px<bpp>::a.set(dest, resA);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-20 14:03:21 +03:00
|
|
|
// scaling via bilinear interpolation algorithm.
|
|
|
|
// NOTE: best results are for scaling in range 50%...200%.
|
|
|
|
// And upscaling looks awful right now - should be fixed somehow
|
2012-05-20 00:38:01 +03:00
|
|
|
SDL_Surface * CSDL_Ext::scaleSurface(SDL_Surface *surf, int width, int height)
|
|
|
|
{
|
|
|
|
if (!surf || !width || !height)
|
|
|
|
return nullptr;
|
2012-05-20 14:03:21 +03:00
|
|
|
|
2012-05-20 00:38:01 +03:00
|
|
|
if (surf->format->palette)
|
2012-06-15 20:08:19 +03:00
|
|
|
return scaleSurfaceFast(surf, width, height);
|
2012-05-20 00:38:01 +03:00
|
|
|
|
2012-05-20 14:03:21 +03:00
|
|
|
//Same size? return copy - this should more be faster
|
|
|
|
if (width == surf->w && height == surf->h)
|
|
|
|
return copySurface(surf);
|
|
|
|
|
2012-05-20 00:38:01 +03:00
|
|
|
SDL_Surface *ret = newSurface(width, height, surf);
|
|
|
|
|
|
|
|
switch(surf->format->BytesPerPixel)
|
|
|
|
{
|
|
|
|
case 2: scaleSurfaceInternal<2>(surf, ret); break;
|
|
|
|
case 3: scaleSurfaceInternal<3>(surf, ret); break;
|
|
|
|
case 4: scaleSurfaceInternal<4>(surf, ret); break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::blitSurface(SDL_Surface * src, const Rect & srcRectInput, SDL_Surface * dst, const Point & dstPoint)
|
2010-08-23 18:16:40 +03:00
|
|
|
{
|
2023-01-18 15:50:52 +02:00
|
|
|
SDL_Rect srcRect = CSDL_Ext::toSDL(srcRectInput);
|
|
|
|
SDL_Rect dstRect = CSDL_Ext::toSDL(Rect(dstPoint, srcRectInput.dimensions()));
|
2010-08-23 18:16:40 +03:00
|
|
|
|
2023-01-30 17:18:59 +02:00
|
|
|
int result = SDL_UpperBlit(src, &srcRect, dst, &dstRect);
|
|
|
|
|
|
|
|
if (result != 0)
|
|
|
|
logGlobal->error("SDL_UpperBlit failed! %s", SDL_GetError());
|
2010-08-23 18:16:40 +03:00
|
|
|
}
|
2010-08-17 15:48:34 +03:00
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::blitSurface(SDL_Surface * src, SDL_Surface * dst, const Point & dest)
|
2010-08-23 19:13:30 +03:00
|
|
|
{
|
2023-01-17 22:01:35 +02:00
|
|
|
Rect allSurface( Point(0,0), Point(src->w, src->h));
|
|
|
|
|
|
|
|
blitSurface(src, allSurface, dst, dest);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::fillSurface( SDL_Surface *dst, const SDL_Color & color )
|
|
|
|
{
|
|
|
|
Rect allSurface( Point(0,0), Point(dst->w, dst->h));
|
|
|
|
|
|
|
|
fillRect(dst, allSurface, color);
|
2010-08-23 19:13:30 +03:00
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::fillRect( SDL_Surface *dst, const Rect & dstrect, const SDL_Color & color )
|
2014-07-05 00:46:55 +03:00
|
|
|
{
|
2023-01-18 15:50:52 +02:00
|
|
|
SDL_Rect newRect = CSDL_Ext::toSDL(dstrect);
|
2023-01-17 22:01:35 +02:00
|
|
|
|
|
|
|
uint32_t sdlColor = SDL_MapRGBA(dst->format, color.r, color.g, color.b, color.a);
|
|
|
|
SDL_FillRect(dst, &newRect, sdlColor);
|
2014-07-05 00:46:55 +03:00
|
|
|
}
|
|
|
|
|
2013-07-07 11:27:27 +03:00
|
|
|
SDL_Color CSDL_Ext::makeColor(ui8 r, ui8 g, ui8 b, ui8 a)
|
|
|
|
{
|
|
|
|
SDL_Color ret = {r, g, b, a};
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::startTextInput(const Rect & whereInput)
|
2014-07-02 18:41:30 +03:00
|
|
|
{
|
2022-07-27 09:58:41 +02:00
|
|
|
#ifdef VCMI_APPLE
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
#endif
|
|
|
|
|
2021-04-19 00:58:14 +02:00
|
|
|
// TODO ios: looks like SDL bug actually, try fixing there
|
|
|
|
auto renderer = SDL_GetRenderer(mainWindow);
|
|
|
|
float scaleX, scaleY;
|
|
|
|
SDL_Rect viewport;
|
|
|
|
SDL_RenderGetScale(renderer, &scaleX, &scaleY);
|
|
|
|
SDL_RenderGetViewport(renderer, &viewport);
|
|
|
|
|
2023-01-17 10:22:11 +02:00
|
|
|
#ifdef VCMI_IOS
|
2022-08-15 15:29:11 +02:00
|
|
|
const auto nativeScale = iOS_utils::screenScale();
|
2023-01-17 10:22:11 +02:00
|
|
|
scaleX /= nativeScale;
|
|
|
|
scaleY /= nativeScale;
|
2021-04-19 00:58:14 +02:00
|
|
|
#endif
|
2022-07-27 09:58:41 +02:00
|
|
|
|
2023-01-29 18:21:55 +02:00
|
|
|
SDL_Rect rectInScreenCoordinates;
|
|
|
|
rectInScreenCoordinates.x = (viewport.x + whereInput.x) * scaleX;
|
|
|
|
rectInScreenCoordinates.y = (viewport.y + whereInput.y) * scaleY;
|
|
|
|
rectInScreenCoordinates.w = whereInput.w * scaleX;
|
|
|
|
rectInScreenCoordinates.h = whereInput.h * scaleY;
|
2023-01-17 10:22:11 +02:00
|
|
|
|
|
|
|
SDL_SetTextInputRect(&rectInScreenCoordinates);
|
|
|
|
|
|
|
|
if (SDL_IsTextInputActive() == SDL_FALSE)
|
|
|
|
{
|
|
|
|
SDL_StartTextInput();
|
|
|
|
}
|
|
|
|
|
2022-07-27 09:58:41 +02:00
|
|
|
#ifdef VCMI_APPLE
|
|
|
|
});
|
|
|
|
#endif
|
2014-07-02 18:41:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::stopTextInput()
|
|
|
|
{
|
2022-07-27 09:58:41 +02:00
|
|
|
#ifdef VCMI_APPLE
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
#endif
|
|
|
|
|
2014-07-02 18:41:30 +03:00
|
|
|
if (SDL_IsTextInputActive() == SDL_TRUE)
|
2016-10-16 01:47:03 +02:00
|
|
|
{
|
|
|
|
SDL_StopTextInput();
|
|
|
|
}
|
2022-07-27 09:58:41 +02:00
|
|
|
|
|
|
|
#ifdef VCMI_APPLE
|
|
|
|
});
|
|
|
|
#endif
|
2014-07-02 18:41:30 +03:00
|
|
|
}
|
|
|
|
|
2014-07-02 21:20:54 +03:00
|
|
|
STRONG_INLINE static uint32_t mapColor(SDL_Surface * surface, SDL_Color color)
|
|
|
|
{
|
2016-10-16 01:47:03 +02:00
|
|
|
return SDL_MapRGBA(surface->format, color.r, color.g, color.b, color.a);
|
2014-07-02 21:20:54 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::setColorKey(SDL_Surface * surface, SDL_Color color)
|
|
|
|
{
|
|
|
|
uint32_t key = mapColor(surface,color);
|
2016-10-16 01:47:03 +02:00
|
|
|
SDL_SetColorKey(surface, SDL_TRUE, key);
|
2014-07-02 21:20:54 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::setDefaultColorKey(SDL_Surface * surface)
|
2016-10-16 01:47:03 +02:00
|
|
|
{
|
2014-07-02 21:20:54 +03:00
|
|
|
setColorKey(surface, Colors::DEFAULT_KEY_COLOR);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::setDefaultColorKeyPresize(SDL_Surface * surface)
|
|
|
|
{
|
2021-08-15 10:16:47 +02:00
|
|
|
uint32_t key = mapColor(surface, Colors::DEFAULT_KEY_COLOR);
|
2014-07-02 21:20:54 +03:00
|
|
|
auto & color = surface->format->palette->colors[key];
|
|
|
|
|
|
|
|
// set color key only if exactly such color was found
|
|
|
|
if (color.r == Colors::DEFAULT_KEY_COLOR.r && color.g == Colors::DEFAULT_KEY_COLOR.g && color.b == Colors::DEFAULT_KEY_COLOR.b)
|
2021-08-15 10:16:47 +02:00
|
|
|
{
|
2016-10-16 01:47:03 +02:00
|
|
|
SDL_SetColorKey(surface, SDL_TRUE, key);
|
2021-08-15 10:16:47 +02:00
|
|
|
color.a = SDL_ALPHA_TRANSPARENT;
|
|
|
|
}
|
2014-07-02 21:20:54 +03:00
|
|
|
}
|
|
|
|
|
2023-01-17 22:01:35 +02:00
|
|
|
void CSDL_Ext::setClipRect(SDL_Surface * src, const Rect & other)
|
|
|
|
{
|
2023-01-18 15:50:52 +02:00
|
|
|
SDL_Rect rect = CSDL_Ext::toSDL(other);
|
2023-01-17 22:01:35 +02:00
|
|
|
|
|
|
|
SDL_SetClipRect(src, &rect);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CSDL_Ext::getClipRect(SDL_Surface * src, Rect & other)
|
|
|
|
{
|
|
|
|
SDL_Rect rect;
|
|
|
|
|
|
|
|
SDL_GetClipRect(src, &rect);
|
|
|
|
|
2023-01-18 15:50:52 +02:00
|
|
|
other = CSDL_Ext::fromSDL(rect);
|
2023-01-17 22:01:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-07-02 18:41:30 +03:00
|
|
|
|
2012-05-18 20:35:46 +03:00
|
|
|
template SDL_Surface * CSDL_Ext::createSurfaceWithBpp<2>(int, int);
|
|
|
|
template SDL_Surface * CSDL_Ext::createSurfaceWithBpp<3>(int, int);
|
2012-11-11 15:23:31 +03:00
|
|
|
template SDL_Surface * CSDL_Ext::createSurfaceWithBpp<4>(int, int);
|
2023-01-17 22:01:35 +02:00
|
|
|
|