games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-11-27 22:49:25 +02:00
Code Issues Releases Activity

Removed most SDL includes from headers, removed SDL int's

Browse Source
This commit is contained in:
Ivan Savenko
2023-01-30 19:55:32 +02:00
parent e14290fde0
commit 9c3030603d
38 changed files with 168 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
client/CMT.cpp
View File

@@ -713,7 +713,7 @@ static bool recreateWindow(int w, int h, int bpp, bool fullscreen, int displayIn
if(nullptr == mainWindow) if(nullptr == mainWindow)
{ {
#if defined(VCMI_ANDROID) || defined(VCMI_IOS) #if defined(VCMI_ANDROID) || defined(VCMI_IOS)
auto createWindow = [displayIndex](Uint32 extraFlags) -> bool { auto createWindow = [displayIndex](uint32_t extraFlags) -> bool {
mainWindow = SDL_CreateWindow(NAME.c_str(), SDL_WINDOWPOS_UNDEFINED_DISPLAY(displayIndex), SDL_WINDOWPOS_UNDEFINED_DISPLAY(displayIndex), 0, 0, SDL_WINDOW_FULLSCREEN | extraFlags); mainWindow = SDL_CreateWindow(NAME.c_str(), SDL_WINDOWPOS_UNDEFINED_DISPLAY(displayIndex), SDL_WINDOWPOS_UNDEFINED_DISPLAY(displayIndex), 0, 0, SDL_WINDOW_FULLSCREEN | extraFlags);
return mainWindow != nullptr; return mainWindow != nullptr;
}; };
@@ -723,7 +723,7 @@ static bool recreateWindow(int w, int h, int bpp, bool fullscreen, int displayIn
SDL_SetHint(SDL_HINT_RETURN_KEY_HIDES_IME, "1"); SDL_SetHint(SDL_HINT_RETURN_KEY_HIDES_IME, "1");
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best"); SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
Uint32 windowFlags = SDL_WINDOW_BORDERLESS | SDL_WINDOW_ALLOW_HIGHDPI; uint32_t windowFlags = SDL_WINDOW_BORDERLESS | SDL_WINDOW_ALLOW_HIGHDPI;
if(!createWindow(windowFlags | SDL_WINDOW_METAL)) if(!createWindow(windowFlags | SDL_WINDOW_METAL))
{ {
logGlobal->warn("Metal unavailable, using OpenGLES"); logGlobal->warn("Metal unavailable, using OpenGLES");

1
client/CMakeLists.txt
View File

@@ -110,7 +110,6 @@ set(client_HEADERS
gui/CIntObject.h gui/CIntObject.h
gui/Fonts.h gui/Fonts.h
gui/TextAlignment.h gui/TextAlignment.h
gui/SDL_Compat.h
gui/SDL_Extensions.h gui/SDL_Extensions.h
gui/SDL_Pixels.h gui/SDL_Pixels.h
gui/NotificationHandler.h gui/NotificationHandler.h

2
client/CMessage.cpp
View File

@@ -22,6 +22,8 @@
#include "widgets/Buttons.h" #include "widgets/Buttons.h"
#include "widgets/TextControls.h" #include "widgets/TextControls.h"
#include <SDL_surface.h>
const int BETWEEN_COMPS_ROWS = 10; const int BETWEEN_COMPS_ROWS = 10;
const int BEFORE_COMPONENTS = 30; const int BEFORE_COMPONENTS = 30;
const int BETWEEN_COMPS = 30; const int BETWEEN_COMPS = 30;

1
client/CPlayerInterface.cpp
View File

@@ -68,6 +68,7 @@
#include "../lib/CGameState.h" #include "../lib/CGameState.h"
#include "gui/NotificationHandler.h" #include "gui/NotificationHandler.h"
#include <SDL_events.h>
// The macro below is used to mark functions that are called by client when game state changes. // The macro below is used to mark functions that are called by client when game state changes.
// They all assume that CPlayerInterface::pim mutex is locked. // They all assume that CPlayerInterface::pim mutex is locked.

2
client/CServerHandler.cpp
View File

@@ -60,6 +60,8 @@
#include <windows.h> #include <windows.h>
#endif #endif
#include <SDL_events.h>
template<typename T> class CApplyOnLobby; template<typename T> class CApplyOnLobby;
const std::string CServerHandler::localhostAddress{"127.0.0.1"}; const std::string CServerHandler::localhostAddress{"127.0.0.1"};

1
client/CVideoHandler.cpp
View File

@@ -16,6 +16,7 @@
#include "../lib/filesystem/Filesystem.h" #include "../lib/filesystem/Filesystem.h"
#include <SDL_render.h> #include <SDL_render.h>
#include <SDL_events.h>
extern CGuiHandler GH; //global gui handler extern CGuiHandler GH; //global gui handler

2
client/ClientCommandManager.cpp
View File

@@ -33,6 +33,8 @@
#include "../lib/ScriptHandler.h" #include "../lib/ScriptHandler.h"
#endif #endif
#include <SDL_surface.h>
void ClientCommandManager::handleGoSolo() void ClientCommandManager::handleGoSolo()
{ {
Settings session = settings.write["session"]; Settings session = settings.write["session"];

2
client/StdInc.h
View File

@@ -2,8 +2,6 @@
#include "../Global.h" #include "../Global.h"
#include "gui/SDL_Compat.h"
// This header should be treated as a pre compiled header file(PCH) in the compiler building settings. // This header should be treated as a pre compiled header file(PCH) in the compiler building settings.
// Here you can add specific libraries and macros which are specific to this project. // Here you can add specific libraries and macros which are specific to this project.

3
client/battle/BattleInterfaceClasses.cpp
View File

@@ -48,6 +48,9 @@
#include "../../lib/CondSh.h" #include "../../lib/CondSh.h"
#include "../../lib/mapObjects/CGTownInstance.h" #include "../../lib/mapObjects/CGTownInstance.h"
#include <SDL_surface.h>
#include <SDL_events.h>
void BattleConsole::showAll(SDL_Surface * to) void BattleConsole::showAll(SDL_Surface * to)
{ {
CIntObject::showAll(to); CIntObject::showAll(to);

3
client/battle/BattleWindow.cpp
View File

@@ -36,6 +36,9 @@
#include "../../lib/CConfigHandler.h" #include "../../lib/CConfigHandler.h"
#include "../../lib/filesystem/ResourceID.h" #include "../../lib/filesystem/ResourceID.h"
#include <SDL_surface.h>
#include <SDL_events.h>
BattleWindow::BattleWindow(BattleInterface & owner): BattleWindow::BattleWindow(BattleInterface & owner):
owner(owner) owner(owner)
{ {

2
client/battle/CreatureAnimation.h
View File

@@ -13,7 +13,7 @@
#include "../widgets/Images.h" #include "../widgets/Images.h"
#include "../gui/CAnimation.h" #include "../gui/CAnimation.h"
#include <SDL_render.h> #include <SDL_pixels.h>
class CIntObject; class CIntObject;
class CreatureAnimation; class CreatureAnimation;

2
client/gui/CAnimation.cpp
View File

@@ -23,6 +23,8 @@
#include "../../lib/CRandomGenerator.h" #include "../../lib/CRandomGenerator.h"
#include "../../lib/vcmi_endian.h" #include "../../lib/vcmi_endian.h"
#include <SDL_surface.h>
class SDLImageLoader; class SDLImageLoader;
typedef std::map <size_t, std::vector <JsonNode> > source_map; typedef std::map <size_t, std::vector <JsonNode> > source_map;

5
client/gui/CGuiHandler.cpp
View File

@@ -24,6 +24,7 @@
#include <SDL_render.h> #include <SDL_render.h>
#include <SDL_timer.h> #include <SDL_timer.h>
#include <SDL_events.h>
extern std::queue<SDL_Event> SDLEventsQueue; extern std::queue<SDL_Event> SDLEventsQueue;
extern boost::mutex eventsM; extern boost::mutex eventsM;
@@ -643,7 +644,7 @@ const Point & CGuiHandler::getCursorPosition() const
void CGuiHandler::drawFPSCounter() void CGuiHandler::drawFPSCounter()
{ {
static SDL_Rect overlay = { 0, 0, 64, 32}; static SDL_Rect overlay = { 0, 0, 64, 32};
Uint32 black = SDL_MapRGB(screen->format, 10, 10, 10); uint32_t black = SDL_MapRGB(screen->format, 10, 10, 10);
SDL_FillRect(screen, &overlay, black); SDL_FillRect(screen, &overlay, black);
std::string fps = boost::lexical_cast<std::string>(mainFPSmng->fps); std::string fps = boost::lexical_cast<std::string>(mainFPSmng->fps);
graphics->fonts[FONT_BIG]->renderTextLeft(screen, fps, Colors::YELLOW, Point(10, 10)); graphics->fonts[FONT_BIG]->renderTextLeft(screen, fps, Colors::YELLOW, Point(10, 10));
@@ -751,7 +752,7 @@ void CFramerateManager::framerateDelay()
// FPS is higher than it should be, then wait some time // FPS is higher than it should be, then wait some time
if(timeElapsed < rateticks) if(timeElapsed < rateticks)
{ {
int timeToSleep = (Uint32)ceil(this->rateticks) - timeElapsed; int timeToSleep = (uint32_t)ceil(this->rateticks) - timeElapsed;
boost::this_thread::sleep(boost::posix_time::milliseconds(timeToSleep)); boost::this_thread::sleep(boost::posix_time::milliseconds(timeToSleep));
} }

4
client/gui/CGuiHandler.h
View File

@@ -10,8 +10,7 @@
#pragma once #pragma once
#include "../../lib/Point.h" #include "../../lib/Point.h"
#include "SDL_keycode.h"
#include <SDL_events.h>
VCMI_LIB_NAMESPACE_BEGIN VCMI_LIB_NAMESPACE_BEGIN
@@ -20,6 +19,7 @@ template <typename T> struct CondSh;
VCMI_LIB_NAMESPACE_END VCMI_LIB_NAMESPACE_END
union SDL_Event; union SDL_Event;
struct SDL_MouseMotionEvent;
class CFramerateManager; class CFramerateManager;
class IStatusBar; class IStatusBar;

2
client/gui/CIntObject.cpp
View File

@@ -15,6 +15,8 @@
#include "../CMessage.h" #include "../CMessage.h"
#include <SDL_pixels.h> #include <SDL_pixels.h>
#include <SDL_surface.h>
#include <SDL_events.h>
IShowActivatable::IShowActivatable() IShowActivatable::IShowActivatable()
{ {

1
client/gui/CursorHandler.cpp
View File

@@ -17,6 +17,7 @@
#include "../../lib/CConfigHandler.h" #include "../../lib/CConfigHandler.h"
#include <SDL_render.h> #include <SDL_render.h>
#include <SDL_events.h>
#ifdef VCMI_APPLE #ifdef VCMI_APPLE
#include <dispatch/dispatch.h> #include <dispatch/dispatch.h>

16
client/gui/Fonts.cpp
View File

@@ -136,7 +136,7 @@ void CBitmapFont::renderCharacter(SDL_Surface * surface, const BitmapChar & char
CSDL_Ext::TColorPutter colorPutter = CSDL_Ext::getPutterFor(surface, 0); CSDL_Ext::TColorPutter colorPutter = CSDL_Ext::getPutterFor(surface, 0);
Uint8 bpp = surface->format->BytesPerPixel; uint8_t bpp = surface->format->BytesPerPixel;
// start of line, may differ from 0 due to end of surface or clipped surface // start of line, may differ from 0 due to end of surface or clipped surface
int lineBegin = std::max<int>(0, clipRect.y - posY); int lineBegin = std::max<int>(0, clipRect.y - posY);
@@ -149,8 +149,8 @@ void CBitmapFont::renderCharacter(SDL_Surface * surface, const BitmapChar & char
//for each line in symbol //for each line in symbol
for(int dy = lineBegin; dy <lineEnd; dy++) for(int dy = lineBegin; dy <lineEnd; dy++)
{ {
Uint8 *dstLine = (Uint8*)surface->pixels; uint8_t *dstLine = (uint8_t*)surface->pixels;
Uint8 *srcLine = character.pixels; uint8_t *srcLine = character.pixels;
// shift source\destination pixels to current position // shift source\destination pixels to current position
dstLine += (posY+dy) * surface->pitch + posX * bpp; dstLine += (posY+dy) * surface->pitch + posX * bpp;
@@ -159,7 +159,7 @@ void CBitmapFont::renderCharacter(SDL_Surface * surface, const BitmapChar & char
//for each column in line //for each column in line
for(int dx = rowBegin; dx < rowEnd; dx++) for(int dx = rowBegin; dx < rowEnd; dx++)
{ {
Uint8* dstPixel = dstLine + dx*bpp; uint8_t* dstPixel = dstLine + dx*bpp;
switch(srcLine[dx]) switch(srcLine[dx])
{ {
case 1: //black "shadow" case 1: //black "shadow"
@@ -307,7 +307,7 @@ void CBitmapHanFont::renderCharacter(SDL_Surface * surface, int characterIndex,
CSDL_Ext::getClipRect(surface, clipRect); CSDL_Ext::getClipRect(surface, clipRect);
CSDL_Ext::TColorPutter colorPutter = CSDL_Ext::getPutterFor(surface, 0); CSDL_Ext::TColorPutter colorPutter = CSDL_Ext::getPutterFor(surface, 0);
Uint8 bpp = surface->format->BytesPerPixel; uint8_t bpp = surface->format->BytesPerPixel;
// start of line, may differ from 0 due to end of surface or clipped surface // start of line, may differ from 0 due to end of surface or clipped surface
int lineBegin = std::max<int>(0, clipRect.y - posY); int lineBegin = std::max<int>(0, clipRect.y - posY);
@@ -320,8 +320,8 @@ void CBitmapHanFont::renderCharacter(SDL_Surface * surface, int characterIndex,
//for each line in symbol //for each line in symbol
for(int dy = lineBegin; dy <lineEnd; dy++) for(int dy = lineBegin; dy <lineEnd; dy++)
{ {
Uint8 *dstLine = (Uint8*)surface->pixels; uint8_t *dstLine = (uint8_t*)surface->pixels;
Uint8 *source = data.first.get() + getCharacterDataOffset(characterIndex); uint8_t *source = data.first.get() + getCharacterDataOffset(characterIndex);
// shift source\destination pixels to current position // shift source\destination pixels to current position
dstLine += (posY+dy) * surface->pitch + posX * bpp; dstLine += (posY+dy) * surface->pitch + posX * bpp;
@@ -333,7 +333,7 @@ void CBitmapHanFont::renderCharacter(SDL_Surface * surface, int characterIndex,
// select current bit in bitmap // select current bit in bitmap
int bit = (source[dx / 8] << (dx % 8)) & 0x80; int bit = (source[dx / 8] << (dx % 8)) & 0x80;
Uint8* dstPixel = dstLine + dx*bpp; uint8_t* dstPixel = dstLine + dx*bpp;
if (bit != 0) if (bit != 0)
colorPutter(dstPixel, color.r, color.g, color.b); colorPutter(dstPixel, color.r, color.g, color.b);
} }

25
client/gui/SDL_Compat.h
View File

@@ -1,25 +0,0 @@
/*
* SDL_Compat.h, 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
*
*/
#pragma once
#include <SDL_version.h>
#if (SDL_MAJOR_VERSION == 2)
#include <SDL_keycode.h>
typedef int SDLX_Coord;
typedef int SDLX_Size;
#else
#error "unknown or unsupported SDL version"
#endif

66
client/gui/SDL_Extensions.cpp
View File

@@ -146,12 +146,12 @@ SDL_Surface * CSDL_Ext::copySurface(SDL_Surface * mod) //returns copy of given s
template<int bpp> template<int bpp>
SDL_Surface * CSDL_Ext::createSurfaceWithBpp(int width, int height) SDL_Surface * CSDL_Ext::createSurfaceWithBpp(int width, int height)
{ {
Uint32 rMask = 0, gMask = 0, bMask = 0, aMask = 0; uint32_t rMask = 0, gMask = 0, bMask = 0, aMask = 0;
Channels::px<bpp>::r.set((Uint8*)&rMask, 255); Channels::px<bpp>::r.set((uint8_t*)&rMask, 255);
Channels::px<bpp>::g.set((Uint8*)&gMask, 255); Channels::px<bpp>::g.set((uint8_t*)&gMask, 255);
Channels::px<bpp>::b.set((Uint8*)&bMask, 255); Channels::px<bpp>::b.set((uint8_t*)&bMask, 255);
Channels::px<bpp>::a.set((Uint8*)&aMask, 255); Channels::px<bpp>::a.set((uint8_t*)&aMask, 255);
return SDL_CreateRGBSurface(0, width, height, bpp * 8, rMask, gMask, bMask, aMask); return SDL_CreateRGBSurface(0, width, height, bpp * 8, rMask, gMask, bMask, aMask);
} }
@@ -230,28 +230,28 @@ SDL_Surface * CSDL_Ext::horizontalFlip(SDL_Surface * toRot)
return ret; return ret;
} }
Uint32 CSDL_Ext::getPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte) uint32_t CSDL_Ext::getPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte)
{ {
int bpp = surface->format->BytesPerPixel; int bpp = surface->format->BytesPerPixel;
/* Here p is the address to the pixel we want to retrieve */ /* Here p is the address to the pixel we want to retrieve */
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp; uint8_t *p = (uint8_t *)surface->pixels + y * surface->pitch + x * bpp;
switch(bpp) switch(bpp)
{ {
case 1: case 1:
if(colorByte) if(colorByte)
return colorToUint32(surface->format->palette->colors+(*p)); return colorTouint32_t(surface->format->palette->colors+(*p));
else else
return *p; return *p;
case 2: case 2:
return *(Uint16 *)p; return *(uint16_t *)p;
case 3: case 3:
return p[0] | p[1] << 8 | p[2] << 16; return p[0] | p[1] << 8 | p[2] << 16;
case 4: case 4:
return *(Uint32 *)p; return *(uint32_t *)p;
default: default:
return 0; // shouldn't happen, but avoids warnings return 0; // shouldn't happen, but avoids warnings
@@ -366,13 +366,13 @@ int CSDL_Ext::blit8bppAlphaTo24bppT(const SDL_Surface * src, const Rect & srcRec
return -1; //if we cannot lock the surface return -1; //if we cannot lock the surface
const SDL_Color *colors = src->format->palette->colors; const SDL_Color *colors = src->format->palette->colors;
Uint8 *colory = (Uint8*)src->pixels + srcy*src->pitch + srcx; uint8_t *colory = (uint8_t*)src->pixels + srcy*src->pitch + srcx;
Uint8 *py = (Uint8*)dst->pixels + dstRect->y*dst->pitch + dstRect->x*bpp; uint8_t *py = (uint8_t*)dst->pixels + dstRect->y*dst->pitch + dstRect->x*bpp;
for(int y=h; y; y--, colory+=src->pitch, py+=dst->pitch) for(int y=h; y; y--, colory+=src->pitch, py+=dst->pitch)
{ {
Uint8 *color = colory; uint8_t *color = colory;
Uint8 *p = py; uint8_t *p = py;
for(int x = w; x; x--) for(int x = w; x; x--)
{ {
@@ -399,9 +399,9 @@ int CSDL_Ext::blit8bppAlphaTo24bpp(const SDL_Surface * src, const Rect & srcRect
} }
} }
Uint32 CSDL_Ext::colorToUint32(const SDL_Color * color) uint32_t CSDL_Ext::colorTouint32_t(const SDL_Color * color)
{ {
Uint32 ret = 0; uint32_t ret = 0;
ret+=color->a; ret+=color->a;
ret<<=8; //*=256 ret<<=8; //*=256
ret+=color->b; ret+=color->b;
@@ -432,7 +432,7 @@ static void drawLineX(SDL_Surface * sur, int x1, int y1, int x2, int y2, const S
uint8_t b = vstd::lerp(color1.b, color2.b, f); uint8_t b = vstd::lerp(color1.b, color2.b, f);
uint8_t a = vstd::lerp(color1.a, color2.a, f); uint8_t a = vstd::lerp(color1.a, color2.a, f);
Uint8 *p = CSDL_Ext::getPxPtr(sur, x, y); uint8_t *p = CSDL_Ext::getPxPtr(sur, x, y);
ColorPutter<4, 0>::PutColor(p, r,g,b,a); ColorPutter<4, 0>::PutColor(p, r,g,b,a);
} }
} }
@@ -449,7 +449,7 @@ static void drawLineY(SDL_Surface * sur, int x1, int y1, int x2, int y2, const S
uint8_t b = vstd::lerp(color1.b, color2.b, f); uint8_t b = vstd::lerp(color1.b, color2.b, f);
uint8_t a = vstd::lerp(color1.a, color2.a, f); uint8_t a = vstd::lerp(color1.a, color2.a, f);
Uint8 *p = CSDL_Ext::getPxPtr(sur, x, y); uint8_t *p = CSDL_Ext::getPxPtr(sur, x, y);
ColorPutter<4, 0>::PutColor(p, r,g,b,a); ColorPutter<4, 0>::PutColor(p, r,g,b,a);
} }
} }
@@ -461,7 +461,7 @@ void CSDL_Ext::drawLine(SDL_Surface * sur, int x1, int y1, int x2, int y2, const
if ( width == 0 && height == 0) if ( width == 0 && height == 0)
{ {
Uint8 *p = CSDL_Ext::getPxPtr(sur, x1, y1); uint8_t *p = CSDL_Ext::getPxPtr(sur, x1, y1);
ColorPutter<4, 0>::PutColorAlpha(p, color1); ColorPutter<4, 0>::PutColorAlpha(p, color1);
return; return;
} }
@@ -579,9 +579,9 @@ CSDL_Ext::TColorPutterAlpha CSDL_Ext::getPutterAlphaFor(SDL_Surface * const &des
#undef CASE_BPP #undef CASE_BPP
} }
Uint8 * CSDL_Ext::getPxPtr(const SDL_Surface * const &srf, const int x, const int y) uint8_t * CSDL_Ext::getPxPtr(const SDL_Surface * const &srf, const int x, const int y)
{ {
return (Uint8 *)srf->pixels + y * srf->pitch + x * srf->format->BytesPerPixel; return (uint8_t *)srf->pixels + y * srf->pitch + x * srf->format->BytesPerPixel;
} }
std::string CSDL_Ext::processStr(std::string str, std::vector<std::string> & tor) std::string CSDL_Ext::processStr(std::string str, std::vector<std::string> & tor)
@@ -629,9 +629,9 @@ void CSDL_Ext::VflipSurf(SDL_Surface * surf)
} }
} }
void CSDL_Ext::putPixelWithoutRefresh(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A) 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)
{ {
Uint8 *p = getPxPtr(ekran, x, y); uint8_t *p = getPxPtr(ekran, x, y);
getPutterFor(ekran, false)(p, R, G, B); getPutterFor(ekran, false)(p, R, G, B);
switch(ekran->format->BytesPerPixel) switch(ekran->format->BytesPerPixel)
@@ -642,7 +642,7 @@ void CSDL_Ext::putPixelWithoutRefresh(SDL_Surface *ekran, const int & x, const i
} }
} }
void CSDL_Ext::putPixelWithoutRefreshIfInSurf(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A) 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)
{ {
const SDL_Rect & rect = ekran->clip_rect; const SDL_Rect & rect = ekran->clip_rect;
@@ -665,7 +665,7 @@ void CSDL_Ext::applyEffectBpp(SDL_Surface * surf, const Rect & rect, int mode )
{ {
for(int yp = rect.y; yp < rect.y + rect.h; ++yp) for(int yp = rect.y; yp < rect.y + rect.h; ++yp)
{ {
Uint8 * pixel = (ui8*)surf->pixels + yp * surf->pitch + xp * surf->format->BytesPerPixel; uint8_t * pixel = (ui8*)surf->pixels + yp * surf->pitch + xp * surf->format->BytesPerPixel;
int r = Channels::px<bpp>::r.get(pixel); int r = Channels::px<bpp>::r.get(pixel);
int g = Channels::px<bpp>::g.get(pixel); int g = Channels::px<bpp>::g.get(pixel);
int b = Channels::px<bpp>::b.get(pixel); int b = Channels::px<bpp>::b.get(pixel);
@@ -698,7 +698,7 @@ void CSDL_Ext::applyEffectBpp(SDL_Surface * surf, const Rect & rect, int mode )
{ {
for(int yp = rect.y; yp < rect.y + rect.h; ++yp) for(int yp = rect.y; yp < rect.y + rect.h; ++yp)
{ {
Uint8 * pixel = (ui8*)surf->pixels + yp * surf->pitch + xp * surf->format->BytesPerPixel; uint8_t * pixel = (ui8*)surf->pixels + yp * surf->pitch + xp * surf->format->BytesPerPixel;
int r = Channels::px<bpp>::r.get(pixel); int r = Channels::px<bpp>::r.get(pixel);
int g = Channels::px<bpp>::g.get(pixel); int g = Channels::px<bpp>::g.get(pixel);
@@ -744,8 +744,8 @@ void scaleSurfaceFastInternal(SDL_Surface *surf, SDL_Surface *ret)
origY = static_cast<int>(floor(factorY * y)); origY = static_cast<int>(floor(factorY * y));
// Get pointers to source pixels // Get pointers to source pixels
Uint8 *srcPtr = (Uint8*)surf->pixels + origY * surf->pitch + origX * bpp; uint8_t *srcPtr = (uint8_t*)surf->pixels + origY * surf->pitch + origX * bpp;
Uint8 *destPtr = (Uint8*)ret->pixels + y * ret->pitch + x * bpp; uint8_t *destPtr = (uint8_t*)ret->pixels + y * ret->pitch + x * bpp;
memcpy(destPtr, srcPtr, bpp); memcpy(destPtr, srcPtr, bpp);
} }
@@ -799,10 +799,10 @@ void scaleSurfaceInternal(SDL_Surface *surf, SDL_Surface *ret)
//assert( w11 + w12 + w21 + w22 > 0.99 && w11 + w12 + w21 + w22 < 1.01);//total weight is ~1.0 //assert( w11 + w12 + w21 + w22 > 0.99 && w11 + w12 + w21 + w22 < 1.01);//total weight is ~1.0
// Get pointers to source pixels // Get pointers to source pixels
Uint8 *p11 = (Uint8*)surf->pixels + int(y1) * surf->pitch + int(x1) * bpp; uint8_t *p11 = (uint8_t*)surf->pixels + int(y1) * surf->pitch + int(x1) * bpp;
Uint8 *p12 = p11 + bpp; uint8_t *p12 = p11 + bpp;
Uint8 *p21 = p11 + surf->pitch; uint8_t *p21 = p11 + surf->pitch;
Uint8 *p22 = p21 + bpp; uint8_t *p22 = p21 + bpp;
// Calculate resulting channels // Calculate resulting channels
#define PX(X, PTR) Channels::px<bpp>::X.get(PTR) #define PX(X, PTR) Channels::px<bpp>::X.get(PTR)
int resR = static_cast<int>(PX(r, p11) * w11 + PX(r, p12) * w12 + PX(r, p21) * w21 + PX(r, p22) * w22); int resR = static_cast<int>(PX(r, p11) * w11 + PX(r, p12) * w12 + PX(r, p21) * w21 + PX(r, p22) * w22);
@@ -811,7 +811,7 @@ void scaleSurfaceInternal(SDL_Surface *surf, SDL_Surface *ret)
int resA = static_cast<int>(PX(a, p11) * w11 + PX(a, p12) * w12 + PX(a, p21) * w21 + PX(a, p22) * w22); int resA = static_cast<int>(PX(a, p11) * w11 + PX(a, p12) * w12 + PX(a, p21) * w21 + PX(a, p22) * w22);
//assert(resR < 256 && resG < 256 && resB < 256 && resA < 256); //assert(resR < 256 && resG < 256 && resB < 256 && resA < 256);
#undef PX #undef PX
Uint8 *dest = (Uint8*)ret->pixels + y * ret->pitch + x * bpp; uint8_t *dest = (uint8_t*)ret->pixels + y * ret->pitch + x * bpp;
Channels::px<bpp>::r.set(dest, resR); Channels::px<bpp>::r.set(dest, resR);
Channels::px<bpp>::g.set(dest, resG); Channels::px<bpp>::g.set(dest, resG);
Channels::px<bpp>::b.set(dest, resB); Channels::px<bpp>::b.set(dest, resB);

16
client/gui/SDL_Extensions.h
View File

@@ -9,11 +9,11 @@
*/ */
#pragma once #pragma once
#include <SDL_events.h>
#include "../../lib/GameConstants.h" #include "../../lib/GameConstants.h"
#include "../../lib/Rect.h" #include "../../lib/Rect.h"
#include "../../lib/Color.h" #include "../../lib/Color.h"
struct SDL_Rect;
struct SDL_Window; struct SDL_Window;
struct SDL_Renderer; struct SDL_Renderer;
struct SDL_Texture; struct SDL_Texture;
@@ -114,8 +114,8 @@ std::string makeNumberShort(IntType number, IntType maxLength = 3) //the output
Rect genRect(const int & hh, const int & ww, const int & xx, const int & yy); Rect genRect(const int & hh, const int & ww, const int & xx, const int & yy);
typedef void (*TColorPutter)(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B); typedef void (*TColorPutter)(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B);
typedef void (*TColorPutterAlpha)(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A); typedef void (*TColorPutterAlpha)(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A);
void blitAt(SDL_Surface * src, int x, int y, SDL_Surface * dst=screen); void blitAt(SDL_Surface * src, int x, int y, SDL_Surface * dst=screen);
void blitAt(SDL_Surface * src, const Rect & pos, SDL_Surface * dst=screen); void blitAt(SDL_Surface * src, const Rect & pos, SDL_Surface * dst=screen);
@@ -131,23 +131,23 @@ typedef void (*TColorPutterAlpha)(Uint8 *&ptr, const Uint8 & R, const Uint8 & G,
void updateRect(SDL_Surface *surface, const Rect & rect); void updateRect(SDL_Surface *surface, const Rect & rect);
void putPixelWithoutRefresh(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A = 255); void 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 = 255);
void putPixelWithoutRefreshIfInSurf(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A = 255); void 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 = 255);
SDL_Surface * verticalFlip(SDL_Surface * toRot); //vertical flip SDL_Surface * verticalFlip(SDL_Surface * toRot); //vertical flip
SDL_Surface * horizontalFlip(SDL_Surface * toRot); //horizontal flip SDL_Surface * horizontalFlip(SDL_Surface * toRot); //horizontal flip
Uint32 getPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte = false); uint32_t getPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte = false);
bool isTransparent(SDL_Surface * srf, int x, int y); //checks if surface is transparent at given position bool isTransparent(SDL_Surface * srf, int x, int y); //checks if surface is transparent at given position
bool isTransparent(SDL_Surface * srf, const Point & position); //checks if surface is transparent at given position bool isTransparent(SDL_Surface * srf, const Point & position); //checks if surface is transparent at given position
Uint8 *getPxPtr(const SDL_Surface * const &srf, const int x, const int y); uint8_t *getPxPtr(const SDL_Surface * const &srf, const int x, const int y);
TColorPutter getPutterFor(SDL_Surface * const &dest, int incrementing); //incrementing: -1, 0, 1 TColorPutter getPutterFor(SDL_Surface * const &dest, int incrementing); //incrementing: -1, 0, 1
TColorPutterAlpha getPutterAlphaFor(SDL_Surface * const &dest, int incrementing); //incrementing: -1, 0, 1 TColorPutterAlpha getPutterAlphaFor(SDL_Surface * const &dest, int incrementing); //incrementing: -1, 0, 1
template<int bpp> template<int bpp>
int blit8bppAlphaTo24bppT(const SDL_Surface * src, const Rect & srcRect, SDL_Surface * dst, const Point & dstPoint); //blits 8 bpp surface with alpha channel to 24 bpp surface int blit8bppAlphaTo24bppT(const SDL_Surface * src, const Rect & srcRect, SDL_Surface * dst, const Point & dstPoint); //blits 8 bpp surface with alpha channel to 24 bpp surface
int blit8bppAlphaTo24bpp(const SDL_Surface * src, const Rect & srcRect, SDL_Surface * dst, const Point & dstPoint); //blits 8 bpp surface with alpha channel to 24 bpp surface int blit8bppAlphaTo24bpp(const SDL_Surface * src, const Rect & srcRect, SDL_Surface * dst, const Point & dstPoint); //blits 8 bpp surface with alpha channel to 24 bpp surface
Uint32 colorToUint32(const SDL_Color * color); //little endian only uint32_t colorTouint32_t(const SDL_Color * color); //little endian only
SDL_Color makeColor(ui8 r, ui8 g, ui8 b, ui8 a); SDL_Color makeColor(ui8 r, ui8 g, ui8 b, ui8 a);
void update(SDL_Surface * what = screen); //updates whole surface (default - main screen) void update(SDL_Surface * what = screen); //updates whole surface (default - main screen)

93
client/gui/SDL_Pixels.h
View File

@@ -12,6 +12,7 @@
#include "SDL_Extensions.h" #include "SDL_Extensions.h"
#include <SDL_endian.h> #include <SDL_endian.h>
#include <SDL_pixels.h>
// for accessing channels from pixel in format-independent way // for accessing channels from pixel in format-independent way
//should be as fast as accessing via pointer at least for 3-4 bytes per pixel //should be as fast as accessing via pointer at least for 3-4 bytes per pixel
@@ -20,20 +21,20 @@ namespace Channels
// channel not present in this format // channel not present in this format
struct channel_empty struct channel_empty
{ {
static STRONG_INLINE void set(Uint8*, Uint8) {} static STRONG_INLINE void set(uint8_t*, uint8_t) {}
static STRONG_INLINE Uint8 get(const Uint8 *) { return 255;} static STRONG_INLINE uint8_t get(const uint8_t *) { return 255;}
}; };
// channel which uses whole pixel // channel which uses whole pixel
template<int offset> template<int offset>
struct channel_pixel struct channel_pixel
{ {
static STRONG_INLINE void set(Uint8 *ptr, Uint8 value) static STRONG_INLINE void set(uint8_t *ptr, uint8_t value)
{ {
ptr[offset] = value; ptr[offset] = value;
} }
static STRONG_INLINE Uint8 get(const Uint8 *ptr) static STRONG_INLINE uint8_t get(const uint8_t *ptr)
{ {
return ptr[offset]; return ptr[offset];
} }
@@ -44,16 +45,16 @@ namespace Channels
struct channel_subpx struct channel_subpx
{ {
static void STRONG_INLINE set(Uint8 *ptr, Uint8 value) static void STRONG_INLINE set(uint8_t *ptr, uint8_t value)
{ {
Uint16 * const pixel = (Uint16*)ptr; uint16_t * const pixel = (uint16_t*)ptr;
Uint8 subpx = value >> (8 - bits); uint8_t subpx = value >> (8 - bits);
*pixel = (*pixel & ~mask) | ((subpx << shift) & mask ); *pixel = (*pixel & ~mask) | ((subpx << shift) & mask );
} }
static Uint8 STRONG_INLINE get(const Uint8 *ptr) static uint8_t STRONG_INLINE get(const uint8_t *ptr)
{ {
Uint8 subpx = (*((Uint16 *)ptr) & mask) >> shift; uint8_t subpx = (*((uint16_t *)ptr) & mask) >> shift;
return (subpx << (8 - bits)) | (subpx >> (2*bits - 8)); return (subpx << (8 - bits)) | (subpx >> (2*bits - 8));
} }
}; };
@@ -122,39 +123,39 @@ namespace Channels
template<int bpp, int incrementPtr> template<int bpp, int incrementPtr>
struct ColorPutter struct ColorPutter
{ {
static STRONG_INLINE void PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B); static STRONG_INLINE void PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B);
static STRONG_INLINE void PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A); static STRONG_INLINE void PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A);
static STRONG_INLINE void PutColorAlphaSwitch(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A); static STRONG_INLINE void PutColorAlphaSwitch(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A);
static STRONG_INLINE void PutColor(Uint8 *&ptr, const SDL_Color & Color); static STRONG_INLINE void PutColor(uint8_t *&ptr, const SDL_Color & Color);
static STRONG_INLINE void PutColorAlpha(Uint8 *&ptr, const SDL_Color & Color); static STRONG_INLINE void PutColorAlpha(uint8_t *&ptr, const SDL_Color & Color);
static STRONG_INLINE void PutColorRow(Uint8 *&ptr, const SDL_Color & Color, size_t count); static STRONG_INLINE void PutColorRow(uint8_t *&ptr, const SDL_Color & Color, size_t count);
}; };
template <int incrementPtr> template <int incrementPtr>
struct ColorPutter<2, incrementPtr> struct ColorPutter<2, incrementPtr>
{ {
static STRONG_INLINE void PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B); static STRONG_INLINE void PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B);
static STRONG_INLINE void PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A); static STRONG_INLINE void PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A);
static STRONG_INLINE void PutColorAlphaSwitch(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A); static STRONG_INLINE void PutColorAlphaSwitch(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A);
static STRONG_INLINE void PutColor(Uint8 *&ptr, const SDL_Color & Color); static STRONG_INLINE void PutColor(uint8_t *&ptr, const SDL_Color & Color);
static STRONG_INLINE void PutColorAlpha(Uint8 *&ptr, const SDL_Color & Color); static STRONG_INLINE void PutColorAlpha(uint8_t *&ptr, const SDL_Color & Color);
static STRONG_INLINE void PutColorRow(Uint8 *&ptr, const SDL_Color & Color, size_t count); static STRONG_INLINE void PutColorRow(uint8_t *&ptr, const SDL_Color & Color, size_t count);
}; };
template<int bpp, int incrementPtr> template<int bpp, int incrementPtr>
STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorAlpha(Uint8 *&ptr, const SDL_Color & Color) STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorAlpha(uint8_t *&ptr, const SDL_Color & Color)
{ {
PutColor(ptr, Color.r, Color.g, Color.b, Color.a); PutColor(ptr, Color.r, Color.g, Color.b, Color.a);
} }
template<int bpp, int incrementPtr> template<int bpp, int incrementPtr>
STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColor(Uint8 *&ptr, const SDL_Color & Color) STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColor(uint8_t *&ptr, const SDL_Color & Color)
{ {
PutColor(ptr, Color.r, Color.g, Color.b); PutColor(ptr, Color.r, Color.g, Color.b);
} }
template<int bpp, int incrementPtr> template<int bpp, int incrementPtr>
STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorAlphaSwitch(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A) STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorAlphaSwitch(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A)
{ {
switch (A) switch (A)
{ {
@@ -166,9 +167,9 @@ STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorAlphaSwitch(Uint8 *&p
return; return;
case 128: // optimized case 128: // optimized
PutColor(ptr, PutColor(ptr,
((Uint16)R + Channels::px<bpp>::r.get(ptr)) >> 1, ((uint16_t)R + Channels::px<bpp>::r.get(ptr)) >> 1,
((Uint16)G + Channels::px<bpp>::g.get(ptr)) >> 1, ((uint16_t)G + Channels::px<bpp>::g.get(ptr)) >> 1,
((Uint16)B + Channels::px<bpp>::b.get(ptr)) >> 1); ((uint16_t)B + Channels::px<bpp>::b.get(ptr)) >> 1);
return; return;
default: default:
PutColor(ptr, R, G, B, A); PutColor(ptr, R, G, B, A);
@@ -177,16 +178,16 @@ STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorAlphaSwitch(Uint8 *&p
} }
template<int bpp, int incrementPtr> template<int bpp, int incrementPtr>
STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A) STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A)
{ {
PutColor(ptr, ((((Uint32)R - (Uint32)Channels::px<bpp>::r.get(ptr))*(Uint32)A) >> 8 ) + (Uint32)Channels::px<bpp>::r.get(ptr), PutColor(ptr, ((((uint32_t)R - (uint32_t)Channels::px<bpp>::r.get(ptr))*(uint32_t)A) >> 8 ) + (uint32_t)Channels::px<bpp>::r.get(ptr),
((((Uint32)G - (Uint32)Channels::px<bpp>::g.get(ptr))*(Uint32)A) >> 8 ) + (Uint32)Channels::px<bpp>::g.get(ptr), ((((uint32_t)G - (uint32_t)Channels::px<bpp>::g.get(ptr))*(uint32_t)A) >> 8 ) + (uint32_t)Channels::px<bpp>::g.get(ptr),
((((Uint32)B - (Uint32)Channels::px<bpp>::b.get(ptr))*(Uint32)A) >> 8 ) + (Uint32)Channels::px<bpp>::b.get(ptr)); ((((uint32_t)B - (uint32_t)Channels::px<bpp>::b.get(ptr))*(uint32_t)A) >> 8 ) + (uint32_t)Channels::px<bpp>::b.get(ptr));
} }
template<int bpp, int incrementPtr> template<int bpp, int incrementPtr>
STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B) STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B)
{ {
static_assert(incrementPtr >= -1 && incrementPtr <= +1, "Invalid incrementPtr value!"); static_assert(incrementPtr >= -1 && incrementPtr <= +1, "Invalid incrementPtr value!");
@@ -204,11 +205,11 @@ STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColor(Uint8 *&ptr, const U
} }
template<int bpp, int incrementPtr> template<int bpp, int incrementPtr>
STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorRow(Uint8 *&ptr, const SDL_Color & Color, size_t count) STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorRow(uint8_t *&ptr, const SDL_Color & Color, size_t count)
{ {
if (count) if (count)
{ {
Uint8 *pixel = ptr; uint8_t *pixel = ptr;
PutColor(ptr, Color.r, Color.g, Color.b); PutColor(ptr, Color.r, Color.g, Color.b);
for (size_t i=0; i<count-1; i++) for (size_t i=0; i<count-1; i++)
@@ -220,12 +221,12 @@ STRONG_INLINE void ColorPutter<bpp, incrementPtr>::PutColorRow(Uint8 *&ptr, cons
} }
template <int incrementPtr> template <int incrementPtr>
STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B) STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B)
{ {
if(incrementPtr == -1) if(incrementPtr == -1)
ptr -= 2; ptr -= 2;
Uint16 * const px = (Uint16*)ptr; uint16_t * const px = (uint16_t*)ptr;
*px = (B>>3) + ((G>>2) << 5) + ((R>>3) << 11); //drop least significant bits of 24 bpp encoded color *px = (B>>3) + ((G>>2) << 5) + ((R>>3) << 11); //drop least significant bits of 24 bpp encoded color
if(incrementPtr == 1) if(incrementPtr == 1)
@@ -233,7 +234,7 @@ STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(Uint8 *&ptr, const Uin
} }
template <int incrementPtr> template <int incrementPtr>
STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColorAlphaSwitch(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A) STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColorAlphaSwitch(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A)
{ {
switch (A) switch (A)
{ {
@@ -250,17 +251,17 @@ STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColorAlphaSwitch(Uint8 *&ptr
} }
template <int incrementPtr> template <int incrementPtr>
STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(Uint8 *&ptr, const Uint8 & R, const Uint8 & G, const Uint8 & B, const Uint8 & A) STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A)
{ {
const int rbit = 5, gbit = 6, bbit = 5; //bits per color const int rbit = 5, gbit = 6, bbit = 5; //bits per color
const int rmask = 0xF800, gmask = 0x7E0, bmask = 0x1F; const int rmask = 0xF800, gmask = 0x7E0, bmask = 0x1F;
const int rshift = 11, gshift = 5, bshift = 0; const int rshift = 11, gshift = 5, bshift = 0;
const Uint8 r5 = (*((Uint16 *)ptr) & rmask) >> rshift, const uint8_t r5 = (*((uint16_t *)ptr) & rmask) >> rshift,
b5 = (*((Uint16 *)ptr) & bmask) >> bshift, b5 = (*((uint16_t *)ptr) & bmask) >> bshift,
g5 = (*((Uint16 *)ptr) & gmask) >> gshift; g5 = (*((uint16_t *)ptr) & gmask) >> gshift;
const Uint32 r8 = (r5 << (8 - rbit)) | (r5 >> (2*rbit - 8)), const uint32_t r8 = (r5 << (8 - rbit)) | (r5 >> (2*rbit - 8)),
g8 = (g5 << (8 - gbit)) | (g5 >> (2*gbit - 8)), g8 = (g5 << (8 - gbit)) | (g5 >> (2*gbit - 8)),
b8 = (b5 << (8 - bbit)) | (b5 >> (2*bbit - 8)); b8 = (b5 << (8 - bbit)) | (b5 >> (2*bbit - 8));
@@ -271,22 +272,22 @@ STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(Uint8 *&ptr, const Uin
} }
template <int incrementPtr> template <int incrementPtr>
STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColorAlpha(Uint8 *&ptr, const SDL_Color & Color) STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColorAlpha(uint8_t *&ptr, const SDL_Color & Color)
{ {
PutColor(ptr, Color.r, Color.g, Color.b, Color.a); PutColor(ptr, Color.r, Color.g, Color.b, Color.a);
} }
template <int incrementPtr> template <int incrementPtr>
STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(Uint8 *&ptr, const SDL_Color & Color) STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColor(uint8_t *&ptr, const SDL_Color & Color)
{ {
PutColor(ptr, Color.r, Color.g, Color.b); PutColor(ptr, Color.r, Color.g, Color.b);
} }
template <int incrementPtr> template <int incrementPtr>
STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColorRow(Uint8 *&ptr, const SDL_Color & Color, size_t count) STRONG_INLINE void ColorPutter<2, incrementPtr>::PutColorRow(uint8_t *&ptr, const SDL_Color & Color, size_t count)
{ {
//drop least significant bits of 24 bpp encoded color //drop least significant bits of 24 bpp encoded color
Uint16 pixel = (Color.b>>3) + ((Color.g>>2) << 5) + ((Color.r>>3) << 11); uint16_t pixel = (Color.b>>3) + ((Color.g>>2) << 5) + ((Color.r>>3) << 11);
for (size_t i=0; i<count; i++) for (size_t i=0; i<count; i++)
{ {

2
client/lobby/CSelectionBase.cpp
View File

@@ -44,6 +44,8 @@
#include "../../lib/mapping/CMapInfo.h" #include "../../lib/mapping/CMapInfo.h"
#include "../../lib/serializer/Connection.h" #include "../../lib/serializer/Connection.h"
#include <SDL_events.h>
ISelectionScreenInfo::ISelectionScreenInfo(ESelectionScreen ScreenType) ISelectionScreenInfo::ISelectionScreenInfo(ESelectionScreen ScreenType)
: screenType(ScreenType) : screenType(ScreenType)
{ {

1
client/lobby/SelectionTab.cpp
View File

@@ -36,6 +36,7 @@
#include "../../lib/mapping/CMapInfo.h" #include "../../lib/mapping/CMapInfo.h"
#include "../../lib/serializer/Connection.h" #include "../../lib/serializer/Connection.h"
#include <SDL_events.h>
bool mapSorter::operator()(const std::shared_ptr<CMapInfo> aaa, const std::shared_ptr<CMapInfo> bbb) bool mapSorter::operator()(const std::shared_ptr<CMapInfo> aaa, const std::shared_ptr<CMapInfo> bbb)
{ {

1
client/mainmenu/CMainMenu.cpp
View File

@@ -56,6 +56,7 @@
#include "../../lib/CondSh.h" #include "../../lib/CondSh.h"
#include "../../lib/mapping/CCampaignHandler.h" #include "../../lib/mapping/CCampaignHandler.h"
#include <SDL_events.h>
namespace fs = boost::filesystem; namespace fs = boost::filesystem;

14
client/widgets/AdventureMapClasses.cpp
View File

@@ -43,6 +43,10 @@
#include "../../lib/mapping/CMap.h" #include "../../lib/mapping/CMap.h"
#include "ClientCommandManager.h" #include "ClientCommandManager.h"
#include <SDL_surface.h>
#include <SDL_keyboard.h>
#include <SDL_events.h>
CList::CListItem::CListItem(CList * Parent) CList::CListItem::CListItem(CList * Parent)
: CIntObject(LCLICK | RCLICK | HOVER), : CIntObject(LCLICK | RCLICK | HOVER),
parent(Parent), parent(Parent),
@@ -187,7 +191,7 @@ CHeroList::CEmptyHeroItem::CEmptyHeroItem()
mana = std::make_shared<CAnimImage>("IMANA", 0, 0, movement->pos.w + portrait->pos.w + 2, 1 ); mana = std::make_shared<CAnimImage>("IMANA", 0, 0, movement->pos.w + portrait->pos.w + 2, 1 );
pos.w = mana->pos.w + mana->pos.x - pos.x; pos.w = mana->pos.w + mana->pos.x - pos.x;
pos.h = std::max(std::max<SDLX_Size>(movement->pos.h + 1, mana->pos.h + 1), portrait->pos.h); pos.h = std::max(std::max<int>(movement->pos.h + 1, mana->pos.h + 1), portrait->pos.h);
} }
CHeroList::CHeroItem::CHeroItem(CHeroList *parent, const CGHeroInstance * Hero) CHeroList::CHeroItem::CHeroItem(CHeroList *parent, const CGHeroInstance * Hero)
@@ -200,7 +204,7 @@ CHeroList::CHeroItem::CHeroItem(CHeroList *parent, const CGHeroInstance * Hero)
mana = std::make_shared<CAnimImage>("IMANA", 0, 0, movement->pos.w + portrait->pos.w + 2, 1); mana = std::make_shared<CAnimImage>("IMANA", 0, 0, movement->pos.w + portrait->pos.w + 2, 1);
pos.w = mana->pos.w + mana->pos.x - pos.x; pos.w = mana->pos.w + mana->pos.x - pos.x;
pos.h = std::max(std::max<SDLX_Size>(movement->pos.h + 1, mana->pos.h + 1), portrait->pos.h); pos.h = std::max(std::max<int>(movement->pos.h + 1, mana->pos.h + 1), portrait->pos.h);
update(); update();
} }
@@ -409,7 +413,7 @@ void CMinimapInstance::blitTileWithColor(const SDL_Color &color, const int3 &til
for (int y=yBegin; y<yEnd; y++) for (int y=yBegin; y<yEnd; y++)
{ {
Uint8 *ptr = (Uint8*)to->pixels + y * to->pitch + xBegin * minimap->format->BytesPerPixel; uint8_t *ptr = (uint8_t*)to->pixels + y * to->pitch + xBegin * minimap->format->BytesPerPixel;
for (int x=xBegin; x<xEnd; x++) for (int x=xBegin; x<xEnd; x++)
ColorPutter<4, 1>::PutColor(ptr, color); ColorPutter<4, 1>::PutColor(ptr, color);
@@ -446,7 +450,7 @@ void CMinimapInstance::drawScaled(int level)
for (int y=yBegin; y<yEnd; y++) for (int y=yBegin; y<yEnd; y++)
{ {
Uint8 *ptr = (Uint8*)minimap->pixels + y * minimap->pitch + xBegin * minimap->format->BytesPerPixel; uint8_t *ptr = (uint8_t*)minimap->pixels + y * minimap->pitch + xBegin * minimap->format->BytesPerPixel;
for (int x=xBegin; x<xEnd; x++) for (int x=xBegin; x<xEnd; x++)
ColorPutter<4, 1>::PutColor(ptr, color); ColorPutter<4, 1>::PutColor(ptr, color);
@@ -948,7 +952,7 @@ void CInGameConsole::show(SDL_Surface * to)
{ {
int number = 0; int number = 0;
std::vector<std::list< std::pair< std::string, Uint32 > >::iterator> toDel; std::vector<std::list< std::pair< std::string, uint32_t > >::iterator> toDel;
boost::unique_lock<boost::mutex> lock(texts_mx); boost::unique_lock<boost::mutex> lock(texts_mx);
for(auto it = texts.begin(); it != texts.end(); ++it, ++number) for(auto it = texts.begin(); it != texts.end(); ++it, ++number)

2
client/widgets/AdventureMapClasses.h
View File

@@ -405,7 +405,7 @@ public:
class CInGameConsole : public CIntObject class CInGameConsole : public CIntObject
{ {
private: private:
std::list< std::pair< std::string, Uint32 > > texts; //list<text to show, time of add> std::list< std::pair< std::string, uint32_t > > texts; //list<text to show, time of add>
boost::mutex texts_mx; // protects texts boost::mutex texts_mx; // protects texts
std::vector< std::string > previouslyEntered; //previously entered texts, for up/down arrows to work std::vector< std::string > previouslyEntered; //previously entered texts, for up/down arrows to work
int prevEntDisp; //displayed entry from previouslyEntered - if none it's -1 int prevEntDisp; //displayed entry from previouslyEntered - if none it's -1

2
client/widgets/Buttons.cpp
View File

@@ -24,6 +24,8 @@
#include "../../lib/CConfigHandler.h" #include "../../lib/CConfigHandler.h"
#include "../../lib/CGeneralTextHandler.h" #include "../../lib/CGeneralTextHandler.h"
#include <SDL_events.h>
void CButton::update() void CButton::update()
{ {
if (overlay) if (overlay)

2
client/widgets/Buttons.h
View File

@@ -13,6 +13,8 @@
#include "../gui/SDL_Extensions.h" #include "../gui/SDL_Extensions.h"
#include "../../lib/FunctionList.h" #include "../../lib/FunctionList.h"
#include <SDL_pixels.h>
VCMI_LIB_NAMESPACE_BEGIN VCMI_LIB_NAMESPACE_BEGIN
namespace config namespace config

4
client/widgets/CGarrisonInt.cpp
View File

@@ -32,6 +32,8 @@
#define SDL_SCANCODE_LCTRL SDL_SCANCODE_LGUI #define SDL_SCANCODE_LCTRL SDL_SCANCODE_LGUI
#endif #endif
#include <SDL_keyboard.h>
void CGarrisonSlot::setHighlight(bool on) void CGarrisonSlot::setHighlight(bool on)
{ {
if (on) if (on)
@@ -437,7 +439,7 @@ void CGarrisonSlot::splitIntoParts(CGarrisonSlot::EGarrisonType type, int amount
bool CGarrisonSlot::handleSplittingShortcuts() bool CGarrisonSlot::handleSplittingShortcuts()
{ {
const Uint8 * state = SDL_GetKeyboardState(NULL); const uint8_t * state = SDL_GetKeyboardState(NULL);
const bool isAlt = !!state[SDL_SCANCODE_LALT]; const bool isAlt = !!state[SDL_SCANCODE_LALT];
const bool isLShift = !!state[SDL_SCANCODE_LSHIFT]; const bool isLShift = !!state[SDL_SCANCODE_LSHIFT];
const bool isLCtrl = !!state[SDL_SCANCODE_LCTRL]; const bool isLCtrl = !!state[SDL_SCANCODE_LCTRL];

2
client/widgets/TextControls.cpp
View File

@@ -24,6 +24,8 @@
#include "lib/CAndroidVMHelper.h" #include "lib/CAndroidVMHelper.h"
#endif #endif
#include <SDL_events.h>
std::string CLabel::visibleText() std::string CLabel::visibleText()
{ {
return text; return text;

2
client/widgets/TextControls.h
View File

@@ -14,6 +14,8 @@
#include "../gui/SDL_Extensions.h" #include "../gui/SDL_Extensions.h"
#include "../../lib/FunctionList.h" #include "../../lib/FunctionList.h"
#include <SDL_pixels.h>
class IImage; class IImage;
class CSlider; class CSlider;

3
client/windows/CAdvmapInterface.cpp
View File

@@ -55,6 +55,9 @@
#include "../../lib/mapping/CMapInfo.h" #include "../../lib/mapping/CMapInfo.h"
#include "../../lib/TerrainHandler.h" #include "../../lib/TerrainHandler.h"
#include <SDL_surface.h>
#include <SDL_events.h>
#define ADVOPT (conf.go()->ac) #define ADVOPT (conf.go()->ac)
using namespace CSDL_Ext; using namespace CSDL_Ext;

10
client/windows/CCastleInterface.cpp
View File

@@ -44,6 +44,8 @@
#include "../../lib/mapObjects/CGHeroInstance.h" #include "../../lib/mapObjects/CGHeroInstance.h"
#include "../../lib/mapObjects/CGTownInstance.h" #include "../../lib/mapObjects/CGTownInstance.h"
#include <SDL_events.h>
CBuildingRect::CBuildingRect(CCastleBuildings * Par, const CGTownInstance * Town, const CStructure * Str) CBuildingRect::CBuildingRect(CCastleBuildings * Par, const CGTownInstance * Town, const CStructure * Str)
: CShowableAnim(0, 0, Str->defName, CShowableAnim::BASE), : CShowableAnim(0, 0, Str->defName, CShowableAnim::BASE),
parent(Par), parent(Par),
@@ -153,10 +155,10 @@ void CBuildingRect::clickRight(tribool down, bool previousState)
SDL_Color multiplyColors(const SDL_Color & b, const SDL_Color & a, double f) SDL_Color multiplyColors(const SDL_Color & b, const SDL_Color & a, double f)
{ {
SDL_Color ret; SDL_Color ret;
ret.r = static_cast<Uint8>(a.r * f + b.r * (1 - f)); ret.r = static_cast<uint8_t>(a.r * f + b.r * (1 - f));
ret.g = static_cast<Uint8>(a.g * f + b.g * (1 - f)); ret.g = static_cast<uint8_t>(a.g * f + b.g * (1 - f));
ret.b = static_cast<Uint8>(a.b * f + b.b * (1 - f)); ret.b = static_cast<uint8_t>(a.b * f + b.b * (1 - f));
ret.a = static_cast<Uint8>(a.a * f + b.b * (1 - f)); ret.a = static_cast<uint8_t>(a.a * f + b.b * (1 - f));
return ret; return ret;
} }

2
client/windows/CSpellWindow.cpp
View File

@@ -42,6 +42,8 @@
#include "../../lib/mapObjects/CGHeroInstance.h" #include "../../lib/mapObjects/CGHeroInstance.h"
#include <SDL_events.h>
CSpellWindow::InteractiveArea::InteractiveArea(const Rect & myRect, std::function<void()> funcL, int helpTextId, CSpellWindow * _owner) CSpellWindow::InteractiveArea::InteractiveArea(const Rect & myRect, std::function<void()> funcL, int helpTextId, CSpellWindow * _owner)
{ {
addUsedEvents(LCLICK | RCLICK | HOVER); addUsedEvents(LCLICK | RCLICK | HOVER);

2
client/windows/CSpellWindow.h
View File

@@ -84,7 +84,7 @@ class CSpellWindow : public CWindowObject
int sitesPerTabBattle[5]; int sitesPerTabBattle[5];
bool battleSpellsOnly; //if true, only battle spells are displayed; if false, only adventure map spells are displayed bool battleSpellsOnly; //if true, only battle spells are displayed; if false, only adventure map spells are displayed
Uint8 selectedTab; // 0 - air magic, 1 - fire magic, 2 - water magic, 3 - earth magic, 4 - all schools uint8_t selectedTab; // 0 - air magic, 1 - fire magic, 2 - water magic, 3 - earth magic, 4 - all schools
int currentPage; //changes when corners are clicked int currentPage; //changes when corners are clicked
std::vector<const CSpell *> mySpells; //all spels in this spellbook std::vector<const CSpell *> mySpells; //all spels in this spellbook

6
client/windows/CWindowObject.cpp
View File

@@ -35,6 +35,8 @@
#include "../../lib/CConfigHandler.h" #include "../../lib/CConfigHandler.h"
#include "../../lib/CGeneralTextHandler.h" //for Unicode related stuff #include "../../lib/CGeneralTextHandler.h" //for Unicode related stuff
#include <SDL_surface.h>
CWindowObject::CWindowObject(int options_, std::string imageName, Point centerAt): CWindowObject::CWindowObject(int options_, std::string imageName, Point centerAt):
WindowBase(getUsedEvents(options_), Point()), WindowBase(getUsedEvents(options_), Point()),
options(options_), options(options_),
@@ -138,7 +140,7 @@ void CWindowObject::setShadow(bool on)
//helper to set last row //helper to set last row
auto blitAlphaRow = [](SDL_Surface *surf, size_t row) auto blitAlphaRow = [](SDL_Surface *surf, size_t row)
{ {
Uint8 * ptr = (Uint8*)surf->pixels + surf->pitch * (row); uint8_t * ptr = (uint8_t*)surf->pixels + surf->pitch * (row);
for (size_t i=0; i< surf->w; i++) for (size_t i=0; i< surf->w; i++)
{ {
@@ -150,7 +152,7 @@ void CWindowObject::setShadow(bool on)
// helper to set last column // helper to set last column
auto blitAlphaCol = [](SDL_Surface *surf, size_t col) auto blitAlphaCol = [](SDL_Surface *surf, size_t col)
{ {
Uint8 * ptr = (Uint8*)surf->pixels + 4 * (col); uint8_t * ptr = (uint8_t*)surf->pixels + 4 * (col);
for (size_t i=0; i< surf->h; i++) for (size_t i=0; i< surf->h; i++)
{ {

2
client/windows/GUIClasses.cpp
View File

@@ -61,6 +61,8 @@
#include "../lib/NetPacksBase.h" #include "../lib/NetPacksBase.h"
#include "../lib/StartInfo.h" #include "../lib/StartInfo.h"
#include <SDL_events.h>
using namespace CSDL_Ext; using namespace CSDL_Ext;
std::list<CFocusable*> CFocusable::focusables; std::list<CFocusable*> CFocusable::focusables;

2
client/windows/InfoWindows.cpp
View File

@@ -39,6 +39,8 @@
#include "../../lib/mapObjects/CGTownInstance.h" #include "../../lib/mapObjects/CGTownInstance.h"
#include "../../lib/mapObjects/MiscObjects.h" #include "../../lib/mapObjects/MiscObjects.h"
#include <SDL_surface.h>
void CSimpleWindow::show(SDL_Surface * to) void CSimpleWindow::show(SDL_Surface * to)
{ {
if(bitmap) if(bitmap)