mirror of
https://github.com/vcmi/vcmi.git
synced 2025-01-04 00:15:53 +02:00
985b4930e4
Windows should be shown using pushInt and closed with popInt or PopIntTotally (if interface needs to be also deleted). Some things are not working yet properly, I'll try to fix them ASAP.
827 lines
22 KiB
C++
827 lines
22 KiB
C++
#include "stdafx.h"
|
|
#include "SDL_Extensions.h"
|
|
#include "SDL_ttf.h"
|
|
#include "CGameInfo.h"
|
|
#include <iostream>
|
|
#include <utility>
|
|
#include <algorithm>
|
|
#include "CMessage.h"
|
|
#include <boost/algorithm/string.hpp>
|
|
#include "hch/CDefHandler.h"
|
|
#include <map>
|
|
#include "client/Graphics.h"
|
|
|
|
SDL_Surface * CSDL_Ext::newSurface(int w, int h, SDL_Surface * mod) //creates new surface, with flags/format same as in surface given
|
|
{
|
|
return SDL_CreateRGBSurface(mod->flags,w,h,mod->format->BitsPerPixel,mod->format->Rmask,mod->format->Gmask,mod->format->Bmask,mod->format->Amask);
|
|
}
|
|
|
|
SDL_Surface * CSDL_Ext::copySurface(SDL_Surface * mod) //returns copy of given surface
|
|
{
|
|
//return SDL_DisplayFormat(mod);
|
|
return SDL_ConvertSurface(mod, mod->format, mod->flags);
|
|
}
|
|
bool isItIn(const SDL_Rect * rect, int x, int y)
|
|
{
|
|
if ((x>rect->x && x<rect->x+rect->w) && (y>rect->y && y<rect->y+rect->h))
|
|
return true;
|
|
else return false;
|
|
}
|
|
|
|
void blitAtWR(SDL_Surface * src, int x, int y, SDL_Surface * dst)
|
|
{
|
|
SDL_Rect pom = genRect(src->h,src->w,x,y);
|
|
SDL_BlitSurface(src,NULL,dst,&pom);
|
|
SDL_UpdateRect(dst,x,y,src->w,src->h);
|
|
}
|
|
void blitAt(SDL_Surface * src, int x, int y, SDL_Surface * dst)
|
|
{
|
|
if(!dst) dst = screen;
|
|
SDL_Rect pom = genRect(src->h,src->w,x,y);
|
|
SDL_BlitSurface(src,NULL,dst,&pom);
|
|
}
|
|
void blitAtWR(SDL_Surface * src, SDL_Rect pos, SDL_Surface * dst)
|
|
{
|
|
blitAtWR(src,pos.x,pos.y,dst);
|
|
}
|
|
void blitAt(SDL_Surface * src, SDL_Rect pos, SDL_Surface * dst)
|
|
{
|
|
blitAt(src,pos.x,pos.y,dst);
|
|
}
|
|
SDL_Color genRGB(int r, int g, int b, int a=0)
|
|
{
|
|
SDL_Color ret;
|
|
ret.b=b;
|
|
ret.g=g;
|
|
ret.r=r;
|
|
ret.unused=a;
|
|
return ret;
|
|
}
|
|
void updateRect (SDL_Rect * rect, SDL_Surface * scr)
|
|
{
|
|
SDL_UpdateRect(scr,rect->x,rect->y,rect->w,rect->h);
|
|
}
|
|
void CSDL_Ext::printAtMiddleWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor, SDL_Surface * dst)
|
|
{
|
|
std::vector<std::string> * ws = CMessage::breakText(text,charpr);
|
|
std::vector<SDL_Surface*> wesu;
|
|
wesu.resize(ws->size());
|
|
for (size_t i=0; i < wesu.size(); ++i)
|
|
{
|
|
wesu[i]=TTF_RenderText_Blended(font,(*ws)[i].c_str(),kolor);
|
|
}
|
|
|
|
int tox=0, toy=0;
|
|
for (size_t i=0; i < wesu.size(); ++i)
|
|
{
|
|
toy+=wesu[i]->h;
|
|
if (tox < wesu[i]->w)
|
|
tox=wesu[i]->w;
|
|
}
|
|
int evx, evy = y - (toy/2);
|
|
for (size_t i=0; i < wesu.size(); ++i)
|
|
{
|
|
evx = (x - (tox/2)) + ((tox-wesu[i]->w)/2);
|
|
blitAt(wesu[i],evx,evy,dst);
|
|
evy+=wesu[i]->h;
|
|
}
|
|
|
|
|
|
for (size_t i=0; i < wesu.size(); ++i)
|
|
SDL_FreeSurface(wesu[i]);
|
|
delete ws;
|
|
}
|
|
void CSDL_Ext::printAtWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor, SDL_Surface * dst)
|
|
{
|
|
std::vector<std::string> * ws = CMessage::breakText(text,charpr);
|
|
std::vector<SDL_Surface*> wesu;
|
|
wesu.resize(ws->size());
|
|
for (size_t i=0; i < wesu.size(); ++i)
|
|
wesu[i]=TTF_RenderText_Blended(font,(*ws)[i].c_str(),kolor);
|
|
|
|
int evy = y;
|
|
for (size_t i=0; i < wesu.size(); ++i)
|
|
{
|
|
blitAt(wesu[i],x,evy,dst);
|
|
evy+=wesu[i]->h;
|
|
}
|
|
|
|
for (size_t i=0; i < wesu.size(); ++i)
|
|
SDL_FreeSurface(wesu[i]);
|
|
delete ws;
|
|
}
|
|
void CSDL_Ext::printAtMiddle(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor, SDL_Surface * dst, unsigned char quality, bool refresh)
|
|
{
|
|
if(text.length()==0) return;
|
|
SDL_Surface * temp;
|
|
switch (quality)
|
|
{
|
|
case 0:
|
|
temp = TTF_RenderText_Solid(font,text.c_str(),kolor);
|
|
break;
|
|
case 1:
|
|
SDL_Color tem;
|
|
tem.b = 0xff-kolor.b;
|
|
tem.g = 0xff-kolor.g;
|
|
tem.r = 0xff-kolor.r;
|
|
tem.unused = 0xff-kolor.unused;
|
|
temp = TTF_RenderText_Shaded(font,text.c_str(),kolor,tem);
|
|
break;
|
|
case 2:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
default:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
}
|
|
SDL_BlitSurface(temp,NULL,dst,&genRect(temp->h,temp->w,x-(temp->w/2),y-(temp->h/2)));
|
|
if(refresh)
|
|
SDL_UpdateRect(dst,x-(temp->w/2),y-(temp->h/2),temp->w,temp->h);
|
|
SDL_FreeSurface(temp);
|
|
}
|
|
void CSDL_Ext::printAt(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor, SDL_Surface * dst, unsigned char quality, bool refresh)
|
|
{
|
|
if (text.length()==0)
|
|
return;
|
|
SDL_Surface * temp;
|
|
switch (quality)
|
|
{
|
|
case 0:
|
|
temp = TTF_RenderText_Solid(font,text.c_str(),kolor);
|
|
break;
|
|
case 1:
|
|
SDL_Color tem;
|
|
tem.b = 0xff-kolor.b;
|
|
tem.g = 0xff-kolor.g;
|
|
tem.r = 0xff-kolor.r;
|
|
tem.unused = 0xff-kolor.unused;
|
|
temp = TTF_RenderText_Shaded(font,text.c_str(),kolor,tem);
|
|
break;
|
|
case 2:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
default:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
}
|
|
SDL_BlitSurface(temp,NULL,dst,&genRect(temp->h,temp->w,x,y));
|
|
if(refresh)
|
|
SDL_UpdateRect(dst,x,y,temp->w,temp->h);
|
|
SDL_FreeSurface(temp);
|
|
}
|
|
|
|
void CSDL_Ext::printAtWR(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor, SDL_Surface * dst, unsigned char quality)
|
|
{
|
|
printAt(text,x,y,font,kolor,dst,quality, true);
|
|
}
|
|
|
|
void CSDL_Ext::printTo(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor, SDL_Surface * dst, unsigned char quality)
|
|
{
|
|
if (text.length()==0)
|
|
return;
|
|
SDL_Surface * temp;
|
|
switch (quality)
|
|
{
|
|
case 0:
|
|
temp = TTF_RenderText_Solid(font,text.c_str(),kolor);
|
|
break;
|
|
case 1:
|
|
SDL_Color tem;
|
|
tem.b = 0xff-kolor.b;
|
|
tem.g = 0xff-kolor.g;
|
|
tem.r = 0xff-kolor.r;
|
|
tem.unused = 0xff-kolor.unused;
|
|
temp = TTF_RenderText_Shaded(font,text.c_str(),kolor,tem);
|
|
break;
|
|
case 2:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
default:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
}
|
|
SDL_BlitSurface(temp,NULL,dst,&genRect(temp->h,temp->w,x-temp->w,y-temp->h));
|
|
SDL_UpdateRect(dst,x-temp->w,y-temp->h,temp->w,temp->h);
|
|
SDL_FreeSurface(temp);
|
|
}
|
|
|
|
void CSDL_Ext::printToWR(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor, SDL_Surface * dst, unsigned char quality)
|
|
{
|
|
if (text.length()==0)
|
|
return;
|
|
SDL_Surface * temp;
|
|
switch (quality)
|
|
{
|
|
case 0:
|
|
temp = TTF_RenderText_Solid(font,text.c_str(),kolor);
|
|
break;
|
|
case 1:
|
|
SDL_Color tem;
|
|
tem.b = 0xff-kolor.b;
|
|
tem.g = 0xff-kolor.g;
|
|
tem.r = 0xff-kolor.r;
|
|
tem.unused = 0xff-kolor.unused;
|
|
temp = TTF_RenderText_Shaded(font,text.c_str(),kolor,tem);
|
|
break;
|
|
case 2:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
default:
|
|
temp = TTF_RenderText_Blended(font,text.c_str(),kolor);
|
|
break;
|
|
}
|
|
SDL_BlitSurface(temp,NULL,dst,&genRect(temp->h,temp->w,x-temp->w,y-temp->h));
|
|
SDL_FreeSurface(temp);
|
|
}
|
|
|
|
inline void CSDL_Ext::SDL_PutPixel(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A)
|
|
{
|
|
Uint8 *p = (Uint8 *)ekran->pixels + y * ekran->pitch + x * ekran->format->BytesPerPixel;
|
|
|
|
p[0] = B;
|
|
p[1] = G;
|
|
p[2] = R;
|
|
if(ekran->format->BytesPerPixel==4)
|
|
p[3] = A;
|
|
|
|
SDL_UpdateRect(ekran, x, y, 1, 1);
|
|
}
|
|
|
|
|
|
|
|
///**************/
|
|
///Reverses the toRot surface by the vertical axis
|
|
///**************/
|
|
SDL_Surface * CSDL_Ext::rotate01(SDL_Surface * toRot)
|
|
{
|
|
SDL_Surface * ret = SDL_ConvertSurface(toRot, toRot->format, toRot->flags);
|
|
//SDL_SetColorKey(ret, SDL_SRCCOLORKEY, toRot->format->colorkey);
|
|
if(toRot->format->BytesPerPixel!=1)
|
|
{
|
|
for(int i=0; i<ret->w; ++i)
|
|
{
|
|
for(int j=0; j<ret->h; ++j)
|
|
{
|
|
{
|
|
Uint8 *p = (Uint8 *)toRot->pixels + j * toRot->pitch + (ret->w - i - 1) * toRot->format->BytesPerPixel;
|
|
CSDL_Ext::SDL_PutPixelWithoutRefresh(ret, i, j, p[2], p[1], p[0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int i=0; i<ret->w; ++i)
|
|
{
|
|
for(int j=0; j<ret->h; ++j)
|
|
{
|
|
{
|
|
Uint8 *p = (Uint8 *)toRot->pixels + j * toRot->pitch + (ret->w - i - 1) * toRot->format->BytesPerPixel;
|
|
(*((Uint8*)ret->pixels + j*ret->pitch + i*ret->format->BytesPerPixel)) = *p;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
SDL_Surface * CSDL_Ext::hFlip(SDL_Surface * toRot)
|
|
{
|
|
SDL_Surface * ret = SDL_ConvertSurface(toRot, toRot->format, toRot->flags);
|
|
//SDL_SetColorKey(ret, SDL_SRCCOLORKEY, toRot->format->colorkey);
|
|
if(ret->format->BytesPerPixel!=1)
|
|
{
|
|
for(int i=0; i<ret->w; ++i)
|
|
{
|
|
for(int j=0; j<ret->h; ++j)
|
|
{
|
|
{
|
|
Uint8 *p = (Uint8 *)toRot->pixels + (ret->h - j -1) * toRot->pitch + i * toRot->format->BytesPerPixel;
|
|
//int k=2;
|
|
/*
|
|
#if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
|
|
CSDL_Ext::SDL_PutPixelWithoutRefresh(ret, i, j, p[0], p[1], p[2]);
|
|
#else
|
|
*/
|
|
CSDL_Ext::SDL_PutPixelWithoutRefresh(ret, i, j, p[2], p[1], p[0]);
|
|
//#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int i=0; i<ret->w; ++i)
|
|
{
|
|
for(int j=0; j<ret->h; ++j)
|
|
{
|
|
{
|
|
Uint8 *p = (Uint8 *)toRot->pixels + (ret->h - j -1) * toRot->pitch + i * toRot->format->BytesPerPixel;
|
|
(*((Uint8*)ret->pixels + j*ret->pitch + i*ret->format->BytesPerPixel)) = *p;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
///**************/
|
|
///Rotates toRot surface by 90 degrees left
|
|
///**************/
|
|
SDL_Surface * CSDL_Ext::rotate02(SDL_Surface * toRot)
|
|
{
|
|
SDL_Surface * ret = SDL_ConvertSurface(toRot, toRot->format, toRot->flags);
|
|
//SDL_SetColorKey(ret, SDL_SRCCOLORKEY, toRot->format->colorkey);
|
|
for(int i=0; i<ret->w; ++i)
|
|
{
|
|
for(int j=0; j<ret->h; ++j)
|
|
{
|
|
{
|
|
Uint8 *p = (Uint8 *)toRot->pixels + i * toRot->pitch + j * toRot->format->BytesPerPixel;
|
|
/*
|
|
#if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
|
|
SDL_PutPixelWithoutRefresh(ret, i, j, p[0], p[1], p[2]);
|
|
#else
|
|
*/
|
|
SDL_PutPixelWithoutRefresh(ret, i, j, p[2], p[1], p[0]);
|
|
//#endif
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
///*************/
|
|
///Rotates toRot surface by 180 degrees
|
|
///*************/
|
|
SDL_Surface * CSDL_Ext::rotate03(SDL_Surface * toRot)
|
|
{
|
|
SDL_Surface * ret = SDL_ConvertSurface(toRot, toRot->format, toRot->flags);
|
|
//SDL_SetColorKey(ret, SDL_SRCCOLORKEY, toRot->format->colorkey);
|
|
if(ret->format->BytesPerPixel!=1)
|
|
{
|
|
for(int i=0; i<ret->w; ++i)
|
|
{
|
|
for(int j=0; j<ret->h; ++j)
|
|
{
|
|
{
|
|
Uint8 *p = (Uint8 *)toRot->pixels + (ret->h - j - 1) * toRot->pitch + (ret->w - i - 1) * toRot->format->BytesPerPixel+2;
|
|
/*
|
|
#if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
|
|
SDL_PutPixelWithoutRefresh(ret, i, j, p[0], p[1], p[2], 0);
|
|
#else
|
|
*/
|
|
SDL_PutPixelWithoutRefresh(ret, i, j, p[2], p[1], p[0], 0);
|
|
//#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int i=0; i<ret->w; ++i)
|
|
{
|
|
for(int j=0; j<ret->h; ++j)
|
|
{
|
|
Uint8 *p = (Uint8 *)toRot->pixels + (ret->h - j - 1) * toRot->pitch + (ret->w - i - 1) * toRot->format->BytesPerPixel;
|
|
(*((Uint8*)ret->pixels + j*ret->pitch + i*ret->format->BytesPerPixel)) = *p;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
Uint32 CSDL_Ext::SDL_GetPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte)
|
|
{
|
|
int bpp = surface->format->BytesPerPixel;
|
|
/* Here p is the address to the pixel we want to retrieve */
|
|
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
|
|
|
|
switch(bpp)
|
|
{
|
|
case 1:
|
|
if(colorByte)
|
|
{
|
|
return colorToUint32(surface->format->palette->colors+(*p));
|
|
}
|
|
else
|
|
return *p;
|
|
|
|
case 2:
|
|
return *(Uint16 *)p;
|
|
|
|
case 3:
|
|
/*
|
|
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
|
|
return p[0] << 16 | p[1] << 8 | p[2];
|
|
#else
|
|
*/
|
|
return p[0] | p[1] << 8 | p[2] << 16;
|
|
//#endif
|
|
|
|
case 4:
|
|
return *(Uint32 *)p;
|
|
|
|
default:
|
|
return 0; // shouldn't happen, but avoids warnings
|
|
}
|
|
}
|
|
|
|
SDL_Surface * CSDL_Ext::alphaTransform(SDL_Surface *src)
|
|
{
|
|
Uint32 trans = SDL_MapRGBA(src->format, 0, 255, 255, 255);
|
|
SDL_SetColorKey(src, 0, trans);
|
|
src->flags|=SDL_SRCALPHA;
|
|
|
|
SDL_Color transp;
|
|
transp.b = transp.g = transp.r = 0;
|
|
transp.unused = 255;
|
|
|
|
if(src->format->BitsPerPixel == 8)
|
|
{
|
|
for(int yy=0; yy<src->format->palette->ncolors; ++yy)
|
|
{
|
|
SDL_Color cur = *(src->format->palette->colors+yy);
|
|
//if(cur.r == 255 && cur.b == 255)
|
|
if(yy==1 || yy==2 || yy==3 || yy==4 || yy==8 || yy==9)
|
|
{
|
|
SDL_Color shadow;
|
|
shadow.b = shadow.g = shadow.r = 0;
|
|
switch(cur.g) //change this values; make diffrerent for objects and shadows (?)
|
|
{
|
|
case 0:
|
|
shadow.unused = 128;
|
|
break;
|
|
case 50:
|
|
shadow.unused = 50+32;
|
|
break;
|
|
case 100:
|
|
shadow.unused = 100+64;
|
|
break;
|
|
case 125:
|
|
shadow.unused = 125+64;
|
|
break;
|
|
case 128:
|
|
shadow.unused = 128+64;
|
|
break;
|
|
case 150:
|
|
shadow.unused = 150+64;
|
|
break;
|
|
default:
|
|
shadow.unused = 255;
|
|
break;
|
|
}
|
|
SDL_SetColors(src, &shadow, yy, 1);
|
|
}
|
|
if(yy==0 || (cur.r == 255 && cur.g == 0 && cur.b == 0))
|
|
{
|
|
SDL_SetColors(src, &transp, yy, 1);
|
|
}
|
|
}
|
|
}
|
|
return src;
|
|
}
|
|
// <=>
|
|
|
|
void prepareOutRect(SDL_Rect &dst, const SDL_Rect *dstRect, const SDL_Rect *clip_rect)
|
|
{
|
|
dst.x = std::max(dstRect->x,clip_rect->x);
|
|
dst.y = std::max(dstRect->y,clip_rect->y);
|
|
dst.w = std::max(0,std::min(dstRect->w - (dst.x - dstRect->x), clip_rect->x + clip_rect->w - dst.x));
|
|
dst.h = std::max(0,std::min(dstRect->h - (dst.y - dstRect->y), clip_rect->y + clip_rect->h - dst.y));
|
|
}
|
|
|
|
void CSDL_Ext::blitWithRotate1(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect)//srcRect is not used, works with 8bpp sources and 24bpp dests
|
|
{
|
|
Uint8 *dp, *sp = (Uint8 *)src->pixels;
|
|
for(int i=0; i<dstRect->h; i++)
|
|
{
|
|
sp += src->w - dstRect->w;
|
|
dp = (Uint8 *)dst->pixels + (i+dstRect->y)*dst->pitch + (dstRect->x+dstRect->w)*dst->format->BytesPerPixel;
|
|
for(int j=0; j<dstRect->w; j++, sp++)
|
|
{
|
|
const SDL_Color * const color = src->format->palette->colors+(*sp);
|
|
*(--dp) = color->r;
|
|
*(--dp) = color->g;
|
|
*(--dp) = color->b;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSDL_Ext::blitWithRotate1clip(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect)//srcRect is not used, works with 8bpp sources and 24bpp dests
|
|
{
|
|
SDL_Rect realDest;
|
|
prepareOutRect(realDest,dstRect,&dst->clip_rect);
|
|
blitWithRotate1(src,srcRect,dst,&realDest);
|
|
}
|
|
|
|
void CSDL_Ext::blitWithRotate2(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect)//srcRect is not used, works with 8bpp sources and 24bpp dests
|
|
{
|
|
Uint8 *dp, *sp = (Uint8 *)src->pixels;
|
|
for(int i=0; i<dstRect->h; i++)
|
|
{
|
|
dp = (Uint8 *)dst->pixels + (dstRect->y + dstRect->h - 1 - i)*dst->pitch + dstRect->x*dst->format->BytesPerPixel;
|
|
for(int j=0; j<dstRect->w; j++, sp++)
|
|
{
|
|
const SDL_Color * const color = src->format->palette->colors+(*sp);
|
|
*(dp++) = color->b;
|
|
*(dp++) = color->g;
|
|
*(dp++) = color->r;
|
|
}
|
|
sp += src->w - dstRect->w;
|
|
}
|
|
}
|
|
|
|
void CSDL_Ext::blitWithRotate2clip(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect)//srcRect is not used, works with 8bpp sources and 24bpp dests
|
|
{
|
|
SDL_Rect realDest;
|
|
prepareOutRect(realDest,dstRect,&dst->clip_rect);
|
|
blitWithRotate2(src,srcRect,dst,&realDest);
|
|
}
|
|
|
|
void CSDL_Ext::blitWithRotate3(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect)//srcRect is not used, works with 8bpp sources and 24bpp dests
|
|
{
|
|
Uint8 *dp, *sp = (Uint8 *)src->pixels;
|
|
for(int i=0; i<dstRect->h; i++)
|
|
{
|
|
sp += src->w - dstRect->w;
|
|
dp = (Uint8 *)dst->pixels + (dstRect->y + dstRect->h - 1 - i)*dst->pitch + (dstRect->x+dstRect->w)*dst->format->BytesPerPixel;
|
|
for(int j=0; j<dstRect->w; j++, sp++)
|
|
{
|
|
const SDL_Color * const color = src->format->palette->colors+(*sp);
|
|
*(--dp) = color->r;
|
|
*(--dp) = color->g;
|
|
*(--dp) = color->b;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSDL_Ext::blitWithRotate3clip(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect)//srcRect is not used, works with 8bpp sources and 24bpp dests
|
|
{
|
|
SDL_Rect realDest;
|
|
prepareOutRect(realDest,dstRect,&dst->clip_rect);
|
|
blitWithRotate3(src,srcRect,dst,&realDest);
|
|
}
|
|
|
|
int CSDL_Ext::blit8bppAlphaTo24bpp(SDL_Surface * src, SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect)
|
|
{
|
|
if(src && src->format->BytesPerPixel==1 && dst && (dst->format->BytesPerPixel==3 || dst->format->BytesPerPixel==4)) //everything's ok
|
|
{
|
|
SDL_Rect fulldst;
|
|
int srcx, srcy, w, h;
|
|
|
|
/* Make sure the surfaces aren't locked */
|
|
if ( ! src || ! dst )
|
|
{
|
|
SDL_SetError("SDL_UpperBlit: passed a NULL surface");
|
|
return(-1);
|
|
}
|
|
if ( src->locked || dst->locked )
|
|
{
|
|
SDL_SetError("Surfaces must not be locked during blit");
|
|
return(-1);
|
|
}
|
|
|
|
/* If the destination rectangle is NULL, use the entire dest surface */
|
|
if ( dstRect == NULL )
|
|
{
|
|
fulldst.x = fulldst.y = 0;
|
|
dstRect = &fulldst;
|
|
}
|
|
|
|
/* clip the source rectangle to the source surface */
|
|
if(srcRect)
|
|
{
|
|
int maxw, maxh;
|
|
|
|
srcx = srcRect->x;
|
|
w = srcRect->w;
|
|
if(srcx < 0)
|
|
{
|
|
w += srcx;
|
|
dstRect->x -= srcx;
|
|
srcx = 0;
|
|
}
|
|
maxw = src->w - srcx;
|
|
if(maxw < w)
|
|
w = maxw;
|
|
|
|
srcy = srcRect->y;
|
|
h = srcRect->h;
|
|
if(srcy < 0)
|
|
{
|
|
h += srcy;
|
|
dstRect->y -= srcy;
|
|
srcy = 0;
|
|
}
|
|
maxh = src->h - srcy;
|
|
if(maxh < h)
|
|
h = maxh;
|
|
|
|
}
|
|
else
|
|
{
|
|
srcx = srcy = 0;
|
|
w = src->w;
|
|
h = src->h;
|
|
}
|
|
|
|
/* clip the destination rectangle against the clip rectangle */
|
|
{
|
|
SDL_Rect *clip = &dst->clip_rect;
|
|
int dx, dy;
|
|
|
|
dx = clip->x - dstRect->x;
|
|
if(dx > 0)
|
|
{
|
|
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;
|
|
if(dy > 0)
|
|
{
|
|
h -= dy;
|
|
dstRect->y += dy;
|
|
srcy += dy;
|
|
}
|
|
dy = dstRect->y + h - clip->y - clip->h;
|
|
if(dy > 0)
|
|
h -= dy;
|
|
}
|
|
|
|
if(w > 0 && h > 0)
|
|
{
|
|
SDL_Rect sr;
|
|
sr.x = srcx;
|
|
sr.y = srcy;
|
|
sr.w = dstRect->w = w;
|
|
sr.h = dstRect->h = h;
|
|
|
|
if(SDL_LockSurface(dst))
|
|
return -1; //if we cannot lock the surface
|
|
|
|
if(dst->format->Rshift==0) //like in most surfaces
|
|
{
|
|
for(Uint16 y=0; y<sr.h; ++y)
|
|
{
|
|
for(Uint16 x=0; x<sr.w; ++x)
|
|
{
|
|
SDL_Color & tbc = src->format->palette->colors[*((Uint8*)src->pixels + (y+sr.y)*src->pitch + x + sr.x)]; //color to blit
|
|
Uint8 * p = (Uint8*)dst->pixels + (y+dstRect->y)*dst->pitch + (x+dstRect->x)*dst->format->BytesPerPixel; //place to blit at
|
|
|
|
// According analyze, the values of tbc.unused are fixed,
|
|
// and the approximate ratios are as following:
|
|
//
|
|
// tbc.unused numbers
|
|
// 192 2679
|
|
// 164 326907
|
|
// 82 705590
|
|
// 214 1292625
|
|
// 128 4842923
|
|
// 0 72138078
|
|
// 255 77547326
|
|
//
|
|
// By making use of such characteristic, we may implement a
|
|
// very fast algorithm for heroes3 without loose much quality.
|
|
switch ((Uint32)tbc.unused)
|
|
{
|
|
case 255:
|
|
break;
|
|
case 0:
|
|
p[0] = tbc.r;
|
|
p[1] = tbc.g;
|
|
p[2] = tbc.b;
|
|
break;
|
|
case 128: // optimized
|
|
p[0] = ((Uint16)tbc.r + (Uint16)p[0]) >> 1;
|
|
p[1] = ((Uint16)tbc.g + (Uint16)p[1]) >> 1;
|
|
p[2] = ((Uint16)tbc.b + (Uint16)p[2]) >> 1;
|
|
break;
|
|
default:
|
|
p[0] = ((((Uint32)p[0]-(Uint32)tbc.r)*(Uint32)tbc.unused) >> 8 + (Uint32)tbc.r) & 0xFF;
|
|
p[1] = ((((Uint32)p[1]-(Uint32)tbc.g)*(Uint32)tbc.unused) >> 8 + (Uint32)tbc.g) & 0xFF;
|
|
p[2] = ((((Uint32)p[2]-(Uint32)tbc.b)*(Uint32)tbc.unused) >> 8 + (Uint32)tbc.b) & 0xFF;
|
|
//p[0] = ((Uint32)tbc.unused*(Uint32)p[0] + (Uint32)tbc.r*(Uint32)(255-tbc.unused))>>8; //red
|
|
//p[1] = ((Uint32)tbc.unused*(Uint32)p[1] + (Uint32)tbc.g*(Uint32)(255-tbc.unused))>>8; //green
|
|
//p[2] = ((Uint32)tbc.unused*(Uint32)p[2] + (Uint32)tbc.b*(Uint32)(255-tbc.unused))>>8; //blue
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(dst->format->Rshift==16) //such as screen
|
|
{
|
|
for(Uint16 y=0; y<sr.h; ++y)
|
|
{
|
|
for(Uint16 x=0; x<sr.w; ++x)
|
|
{
|
|
SDL_Color & tbc = src->format->palette->colors[*((Uint8*)src->pixels + (y+sr.y)*src->pitch + x + sr.x)]; //color to blit
|
|
Uint8 * p = (Uint8*)dst->pixels + (y+dstRect->y)*dst->pitch + (x+dstRect->x)*dst->format->BytesPerPixel; //place to blit at
|
|
|
|
switch ((Uint32)tbc.unused)
|
|
{
|
|
case 255:
|
|
break;
|
|
case 0:
|
|
p[2] = tbc.r;
|
|
p[1] = tbc.g;
|
|
p[0] = tbc.b;
|
|
break;
|
|
case 128: // optimized
|
|
p[2] = ((Uint16)tbc.r + (Uint16)p[2]) >> 1;
|
|
p[1] = ((Uint16)tbc.g + (Uint16)p[1]) >> 1;
|
|
p[0] = ((Uint16)tbc.b + (Uint16)p[0]) >> 1;
|
|
break;
|
|
default:
|
|
p[2] = ((((Uint32)p[2]-(Uint32)tbc.r)*(Uint32)tbc.unused) >> 8 + (Uint32)tbc.r) & 0xFF;
|
|
p[1] = ((((Uint32)p[1]-(Uint32)tbc.g)*(Uint32)tbc.unused) >> 8 + (Uint32)tbc.g) & 0xFF;
|
|
p[0] = ((((Uint32)p[0]-(Uint32)tbc.b)*(Uint32)tbc.unused) >> 8 + (Uint32)tbc.b) & 0xFF;
|
|
//p[2] = ((Uint32)tbc.unused*(Uint32)p[2] + (Uint32)tbc.r*(Uint32)(255-tbc.unused))>>8; //red
|
|
//p[1] = ((Uint32)tbc.unused*(Uint32)p[1] + (Uint32)tbc.g*(Uint32)(255-tbc.unused))>>8; //green
|
|
//p[0] = ((Uint32)tbc.unused*(Uint32)p[0] + (Uint32)tbc.b*(Uint32)(255-tbc.unused))>>8; //blue
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SDL_UnlockSurface(dst);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Uint32 CSDL_Ext::colorToUint32(const SDL_Color * color)
|
|
{
|
|
Uint32 ret = 0;
|
|
ret+=color->unused;
|
|
ret<<=8; //*=256
|
|
ret+=color->b;
|
|
ret<<=8; //*=256
|
|
ret+=color->g;
|
|
ret<<=8; //*=256
|
|
ret+=color->r;
|
|
return ret;
|
|
}
|
|
|
|
void CSDL_Ext::update(SDL_Surface * what)
|
|
{
|
|
if(what)
|
|
SDL_UpdateRect(what, 0, 0, what->w, what->h);
|
|
}
|
|
void CSDL_Ext::drawBorder(SDL_Surface * sur, int x, int y, int w, int h, int3 color)
|
|
{
|
|
for(int i=0;i<w;i++)
|
|
{
|
|
SDL_PutPixelWithoutRefresh(sur,x+i,y,color.x,color.y,color.z);
|
|
SDL_PutPixelWithoutRefresh(sur,x+i,y+h-1,color.x,color.y,color.z);
|
|
}
|
|
for(int i=0; i<h;i++)
|
|
{
|
|
SDL_PutPixelWithoutRefresh(sur,x,y+i,color.x,color.y,color.z);
|
|
SDL_PutPixelWithoutRefresh(sur,x+w-1,y+i,color.x,color.y,color.z);
|
|
}
|
|
}
|
|
void CSDL_Ext::setPlayerColor(SDL_Surface * sur, unsigned char player)
|
|
{
|
|
if(player==254)
|
|
return;
|
|
if(sur->format->BitsPerPixel==8)
|
|
{
|
|
if(player != 255)
|
|
*(sur->format->palette->colors+5) = graphics->playerColors[player];
|
|
else
|
|
*(sur->format->palette->colors+5) = *graphics->neutralColor;
|
|
}
|
|
}
|
|
int readNormalNr (std::istream &in, int bytCon)
|
|
{
|
|
int ret=0;
|
|
int amp=1;
|
|
unsigned char byte;
|
|
if (in.good())
|
|
{
|
|
for (int i=0; i<bytCon; i++)
|
|
{
|
|
in.read((char*)&byte,1);
|
|
ret+=byte*amp;
|
|
amp<<=8;
|
|
}
|
|
}
|
|
else return -1;
|
|
return ret;
|
|
}
|
|
|
|
std::string CSDL_Ext::processStr(std::string str, std::vector<std::string> & tor)
|
|
{
|
|
for (size_t i=0; (i<tor.size())&&(boost::find_first(str,"%s")); ++i)
|
|
{
|
|
boost::replace_first(str,"%s",tor[i]);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
SDL_Surface * CSDL_Ext::std32bppSurface = NULL;
|