surface surface::create_surface(uint32_t flags, int width, int height, int depth,
uint32_t Rmask, uint32_t Gmask, uint32_t Bmask, uint32_t Amask) {
return surface().build(SDL_CreateRGBSurface(flags,width,height,depth
,Rmask,Gmask,Bmask,Amask));
}
void Draw(SDL_Surface *screen)
{
int rate,x,y,s;
SDL_Rect dest,clip;
SDL_Surface *texture_image;
SDL_Surface *texture_target1;
SDL_Surface *texture_target2;
FPSmanager fpsm;
Uint32 rmask, gmask, bmask, amask;
int width_half = screen->w/2;
int height_half = screen->h/2;
Uint32 text_color = 0xffffffff;
/* Define masks for 32bit surface */
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
/* Create semi-transparent textured surface */
s=64;
texture_image = SDL_DisplayFormatAlpha(SDL_CreateRGBSurface(SDL_SWSURFACE, s, s, 32, rmask, gmask, bmask, amask));
/* Add some color */
boxRGBA(texture_image, 0, 0, s/2, s/2, 255, 0, 0, 255);
boxRGBA(texture_image, s/2, 0, s, s/2, 0, 255, 0, 255);
boxRGBA(texture_image, 0, s/2, s/2, s, 0, 0, 255, 255);
boxRGBA(texture_image, s/2, s/2, s, s, 255, 255, 255, 255);
/* Make 75%-transparent */
SDL_gfxSetAlpha(texture_image, 96);
/* Set alpha channel use to per-pixel blending */
SDL_SetAlpha(texture_image, SDL_SRCALPHA, 255);
/* Create an all transparent surface */
texture_target1 = SDL_DisplayFormatAlpha(SDL_CreateRGBSurface(SDL_SWSURFACE, 256, 256, 32, rmask, gmask, bmask, amask));
/* Make 75%-transparent */
SDL_gfxSetAlpha(texture_target1, 64);
/* Set alpha channel use to per-pixel blending */
SDL_SetAlpha(texture_target1, SDL_SRCALPHA, 255);
/* Create an all transparent surface (2) */
texture_target2 = SDL_DisplayFormatAlpha(SDL_CreateRGBSurface(SDL_SWSURFACE, 256, 256, 32, rmask, gmask, bmask, amask));
/* Make 75%-transparent */
SDL_gfxSetAlpha(texture_target2, 64);
/* Set alpha channel use to per-pixel blending */
SDL_SetAlpha(texture_target2, SDL_SRCALPHA, 255);
/* Define clipping region for left box */
clip.x = width_half-256-10 ;
clip.y = height_half-256/2 ;
clip.w = 256;
clip.h = 256;
/* Initialize Framerate manager */
SDL_initFramerate(&fpsm);
/* Set/switch framerate */
rate=5;
SDL_setFramerate(&fpsm,rate);
/* --- Drawing loop */
while (1) {
/* Event handler */
HandleEvent();
/* Black screen */
ClearScreen(screen);
/* Random position of new texture */
x=(rand() % (256+2*s))-s;
y=(rand() % (256+2*s))-s;
/* Same for comparison texture */
dest.x = x;
dest.y = y;
dest.w = texture_image->w;
dest.h = texture_image->h;
SDL_BlitSurface(texture_image, NULL, texture_target1, &dest);
/* Blit image into the target using custom Blit function. */
dest.x = x;
dest.y = y;
dest.w = texture_image->w;
dest.h = texture_image->h;
SDL_gfxBlitRGBA(texture_image, NULL, texture_target2, &dest);
/* Draw comparison target on screen (left) */
dest.x = width_half-256-10;
dest.y = height_half-256/2;
dest.w = 256;
dest.h = 256;
SDL_BlitSurface(texture_target1, NULL, screen, &dest);
/* Draw combiner target on screen (right) */
dest.x = width_half+10;
dest.y = height_half-256/2;
dest.w = 256;
dest.h = 256;
SDL_BlitSurface(texture_target2, NULL, screen, &dest);
/* Draw some frames with titles */
rectangleColor(screen, width_half-256-10-1, height_half-256/2-1, width_half-256-10-1+257, height_half-256/2-1+257, text_color);
rectangleColor(screen, width_half+10-1, height_half-256/2-1, width_half+10-1+257, height_half-256/2-1+257, text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-36, " SDL Standard Blitter ", text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-24, "Image --sdlBlit--> Target1", text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-12, "Target1 --sdlBlit--> Screen", text_color);
stringColor(screen, width_half+10-1, height_half-256/2-1-36, " SDL_gfx Compositing Blitter", text_color);
stringColor(screen, width_half+10-1, height_half-256/2-1-24, "Image --gfxBlit--> Target2", text_color);
stringColor(screen, width_half+10-1, height_half-256/2-1-12, "Target2 --sdlBlit--> Screen", text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-60, "gfxBlitRGBA Demo: Target1/2 A=64 (25%), Image A=96 (37%)", text_color);
/* Display by flipping screens */
SDL_Flip(screen);
/* Delay to fix rate */
SDL_framerateDelay(&fpsm);
}
}
//------------------------------------------------------------------------
bool platform_support::init(unsigned width, unsigned height, unsigned flags)
{
m_window_flags = flags;
unsigned wflags = SDL_SWSURFACE;
if(m_window_flags & window_hw_buffer)
{
wflags = SDL_HWSURFACE;
}
if(m_window_flags & window_resize)
{
wflags |= SDL_RESIZABLE;
}
if(m_specific->m_surf_screen) SDL_FreeSurface(m_specific->m_surf_screen);
m_specific->m_surf_screen = SDL_SetVideoMode(width, height, m_bpp, wflags);
if(m_specific->m_surf_screen == 0)
{
fprintf(stderr,
"Unable to set %dx%d %d bpp video: %s\n",
width,
height,
m_bpp,
::SDL_GetError());
return false;
}
SDL_WM_SetCaption(m_caption, 0);
if(m_specific->m_surf_window) SDL_FreeSurface(m_specific->m_surf_window);
m_specific->m_surf_window =
SDL_CreateRGBSurface(SDL_HWSURFACE,
m_specific->m_surf_screen->w,
m_specific->m_surf_screen->h,
m_specific->m_surf_screen->format->BitsPerPixel,
m_specific->m_rmask,
m_specific->m_gmask,
m_specific->m_bmask,
m_specific->m_amask);
if(m_specific->m_surf_window == 0)
{
fprintf(stderr,
"Unable to create image buffer %dx%d %d bpp: %s\n",
width,
height,
m_bpp,
SDL_GetError());
return false;
}
m_rbuf_window.attach((unsigned char*)m_specific->m_surf_window->pixels,
m_specific->m_surf_window->w,
m_specific->m_surf_window->h,
m_flip_y ? -m_specific->m_surf_window->pitch :
m_specific->m_surf_window->pitch);
if(!m_specific->m_initialized)
{
m_initial_width = width;
m_initial_height = height;
on_init();
m_specific->m_initialized = true;
}
on_resize(m_rbuf_window.width(), m_rbuf_window.height());
m_specific->m_update_flag = true;
return true;
}
VOID
PAL_ScrollFBP(
WORD wChunkNum,
WORD wScrollSpeed,
BOOL fScrollDown
)
/*++
Purpose:
Scroll up an FBP picture to the screen.
Parameters:
[IN] wChunkNum - number of chunk in fbp.mkf file.
[IN] wScrollSpeed - scrolling speed of showing the picture.
[IN] fScrollDown - TRUE if scroll down, FALSE if scroll up.
Return value:
None.
--*/
{
SDL_Surface *p;
PAL_LARGE BYTE buf[320 * 200];
PAL_LARGE BYTE bufSprite[320 * 200];
int i, l;
SDL_Rect rect, dstrect;
if (PAL_MKFDecompressChunk(buf, 320 * 200, wChunkNum, gpGlobals->f.fpFBP) <= 0)
{
return;
}
if (g_wCurEffectSprite != 0)
{
PAL_MKFDecompressChunk(bufSprite, 320 * 200, g_wCurEffectSprite, gpGlobals->f.fpMGO);
}
p = SDL_CreateRGBSurface(gpScreen->flags & ~SDL_HWSURFACE, 320, 200, 8,
gpScreen->format->Rmask, gpScreen->format->Gmask,
gpScreen->format->Bmask, gpScreen->format->Amask);
if (p == NULL)
{
return;
}
VIDEO_BackupScreen();
PAL_FBPBlitToSurface(buf, p);
if (wScrollSpeed == 0)
{
wScrollSpeed = 1;
}
rect.x = 0;
rect.w = 320;
dstrect.x = 0;
dstrect.w = 320;
for (l = 0; l < 220; l++)
{
i = l;
if (i > 200)
{
i = 200;
}
if (fScrollDown)
{
rect.y = 0;
dstrect.y = i;
rect.h = 200 - i;
dstrect.h = 200 - i;
}
else
{
rect.y = i;
dstrect.y = 0;
rect.h = 200 - i;
dstrect.h = 200 - i;
}
SDL_BlitSurface(gpScreenBak, &rect, gpScreen, &dstrect);
if (fScrollDown)
{
rect.y = 200 - i;
dstrect.y = 0;
rect.h = i;
dstrect.h = i;
}
else
{
rect.y = 0;
dstrect.y = 200 - i;
rect.h = i;
dstrect.h = i;
}
SDL_BlitSurface(p, &rect, gpScreen, &dstrect);
PAL_ApplyWave(gpScreen);
if (g_wCurEffectSprite != 0)
{
int f = SDL_GetTicks() / 150;
PAL_RLEBlitToSurface(PAL_SpriteGetFrame(bufSprite, f % PAL_SpriteGetNumFrames(bufSprite)),
gpScreen, PAL_XY(0, 0));
}
VIDEO_UpdateScreen(NULL);
if (gpGlobals->fNeedToFadeIn)
{
PAL_FadeIn(gpGlobals->wNumPalette, gpGlobals->fNightPalette, 1);
gpGlobals->fNeedToFadeIn = FALSE;
}
UTIL_Delay(800 / wScrollSpeed);
}
SDL_BlitSurface(p, NULL, gpScreen, NULL);
SDL_FreeSurface(p);
VIDEO_UpdateScreen(NULL);
}
VOID
PAL_ShowFBP(
WORD wChunkNum,
WORD wFade
)
/*++
Purpose:
Draw an FBP picture to the screen.
Parameters:
[IN] wChunkNum - number of chunk in fbp.mkf file.
[IN] wFade - fading speed of showing the picture.
Return value:
None.
--*/
{
PAL_LARGE BYTE buf[320 * 200];
PAL_LARGE BYTE bufSprite[320 * 200];
const int rgIndex[6] = {0, 3, 1, 5, 2, 4};
SDL_Surface *p;
int i, j, k;
BYTE a, b;
if (PAL_MKFDecompressChunk(buf, 320 * 200, wChunkNum, gpGlobals->f.fpFBP) <= 0)
{
memset(buf, 0, sizeof(buf));
}
if (g_wCurEffectSprite != 0)
{
PAL_MKFDecompressChunk(bufSprite, 320 * 200, g_wCurEffectSprite, gpGlobals->f.fpMGO);
}
if (wFade)
{
wFade++;
wFade *= 10;
p = SDL_CreateRGBSurface(gpScreen->flags & ~SDL_HWSURFACE, 320, 200, 8,
gpScreen->format->Rmask, gpScreen->format->Gmask,
gpScreen->format->Bmask, gpScreen->format->Amask);
PAL_FBPBlitToSurface(buf, p);
VIDEO_BackupScreen();
for (i = 0; i < 16; i++)
{
for (j = 0; j < 6; j++)
{
//
// Blend the pixels in the 2 buffers, and put the result into the
// backup buffer
//
for (k = rgIndex[j]; k < gpScreen->pitch * gpScreen->h; k += 6)
{
a = ((LPBYTE)(p->pixels))[k];
b = ((LPBYTE)(gpScreenBak->pixels))[k];
if (i > 0)
{
if ((a & 0x0F) > (b & 0x0F))
{
b++;
}
else if ((a & 0x0F) < (b & 0x0F))
{
b--;
}
}
((LPBYTE)(gpScreenBak->pixels))[k] = ((a & 0xF0) | (b & 0x0F));
}
SDL_BlitSurface(gpScreenBak, NULL, gpScreen, NULL);
if (g_wCurEffectSprite != 0)
{
int f = SDL_GetTicks() / 150;
PAL_RLEBlitToSurface(PAL_SpriteGetFrame(bufSprite, f % PAL_SpriteGetNumFrames(bufSprite)),
gpScreen, PAL_XY(0, 0));
}
VIDEO_UpdateScreen(NULL);
UTIL_Delay(wFade);
}
}
SDL_FreeSurface(p);
}
//
// HACKHACK: to make the ending show correctly
//
if (wChunkNum != 49)
{
PAL_FBPBlitToSurface(buf, gpScreen);
}
VIDEO_UpdateScreen(NULL);
}
void Renderer::init()
{
for (int i = 0;i < 10;i++) {
effectList[i].duration = 0;
}
if ( SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO) < 0 ) {
fprintf(stderr, "Impossible d'initialiser SDL: %s\n", SDL_GetError());
exit(1);
}
//atexit(SDL_Quit);
SDL_Init(SDL_INIT_VIDEO);
// Version d'OpenGL
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
// Double Buffer
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
displayWindow = SDL_CreateWindow("Test SDL 2.0", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Renderer::screenWidth, Renderer::screenHeight, SDL_WINDOW_OPENGL);
// Création du contexte OpenGL
contexteOpenGL = SDL_GL_CreateContext(displayWindow);
if(contexteOpenGL == 0)
{
std::cout << SDL_GetError() << std::endl; //// >> AFFICHE : " the specified window isn't an OpenGL window"
SDL_DestroyWindow(displayWindow);
SDL_Quit();
exit(-1); //// >> PLANTE ICI : return -1 ..
}
if (TTF_Init() < 0) {
puts("ERROR : unable to initialize font library");
exit(1);
}
//this->font = TTF_OpenFont( "INSPIRAT.ttf", 28 );
this->font = TTF_OpenFont( "digital display tfb.ttf",28);
if (this->font == NULL)
{
puts("ERROR : unable to load font");
exit(1);
}
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
unsigned int rmask = 0xff000000;
unsigned int gmask = 0x00ff0000;
unsigned int bmask = 0x0000ff00;
unsigned int amask = 0x000000ff;
#else
unsigned int rmask = 0x000000ff;
unsigned int gmask = 0x0000ff00;
unsigned int bmask = 0x00ff0000;
unsigned int amask = 0xff000000;
#endif
this->textSurface = SDL_CreateRGBSurface( 0, Renderer::screenWidth, Renderer::screenHeight, 32, rmask, gmask, bmask, amask);
OGLRenderableFactory factory = OGLRenderableFactory();
this->game = GameFactory::loadGame("game.xml");
this->game->loadCurrentLevel(&factory);
bExit = false;
soundManager = new SoundManager();
soundManager->init();
//soundManager->loadMusic("A991Project.ogg");
//soundManager->playCurrentMusic();
//soundManager->loadExplosionSound("Grenade-SoundBible.com-1777900486.wav");
particleManager = new ParticleManager();
/*
drawthread = SDL_CreateThread(thread_func, this);
if ( drawthread == NULL ) {
fprintf(stderr, "Unable to create draw thread: %s\n", SDL_GetError());
exit(0);
}
*/
this->game->setOnDestroyCallback(onDestroyCallback,this);
this->game->setOnHitCallback(onHitCallback,this);
this->fbAccumulation = NULL;
this->fbDrawing = NULL;
this->fbHalfRes1 = NULL;
this->fbHalfRes2 = NULL;
shaderTexturing = new Shader();
shaderTexturing->load_fragment("fragment_texturing.gl");
shaderTexturing->load_vertex("test.gl");
shaderDistort = new Shader();
shaderDistort->load_fragment("fragment_distort.gl");
shaderDistort->load_vertex("test.gl");
shaderGaussianBlurVertical = new Shader();
shaderGaussianBlurVertical->load_fragment("fragment_gaussian_vertical.gl");
shaderGaussianBlurVertical->load_vertex("test02.gl");
shaderGaussianBlurHorizontal = new Shader();
shaderGaussianBlurHorizontal->load_fragment("fragment_gaussian_horizontal.gl");
shaderGaussianBlurHorizontal->load_vertex("test02.gl");
Texture * texture = new Texture(2,2,(unsigned char*)g_texdata);
unsigned int * pixels = (unsigned int *)malloc(sizeof(unsigned int)*30*30);
TextureGenerator::generateTriangle(10,4,pixels,30,0xffffffff);
this->spriteAccumulation = new Sprite(texture,100.f,100.f,0,0,1,1);
this->spriteBullet = new Sprite(texture,5.f,5.f,1,1,0,0);
this->spriteDrawing = new Sprite(texture,100.f,100.f,0,0,1,1);
this->spriteDummy = new Sprite(texture,100.f,100.f,0,0,1,1);
this->spriteCovering = new Sprite(texture,Renderer::screenWidth,Renderer::screenHeight,0,0,1,1);
this->spriteRectangle = new Sprite(texture,10.f,1.f,0,0,1,1);
unsigned int * pixels2 = (unsigned int *)malloc(sizeof(unsigned int)*30*30);
TextureGenerator::generateCircle(0,0,pixels2,30,0xffffffff);
this->spriteCircle = new Sprite(new Texture(30,30,(unsigned char*)pixels2),10.f,10.f,1,1,0,0);
//this->spriteCircle = this->spriteBullet;
Texture * textSurfaceTexture = new Texture(Renderer::screenWidth,Renderer::screenHeight,(unsigned char*)this->textSurface->pixels);
this->spriteTextSurface = new Sprite(textSurfaceTexture,Renderer::screenWidth,Renderer::screenHeight,0,1,1,0);
this->spriteShip = new Sprite(new Texture(30,30,(unsigned char*)pixels),30.f,30.f,1,1,0,0);
unsigned int * pixelsgrid = (unsigned int*)malloc(sizeof(unsigned int)* 100 * 100);
TextureGenerator::generateGrid(pixelsgrid,100,100,20,0xff0909aa);
this->spriteGrid = new Sprite(new Texture(100,100,(unsigned char*)pixelsgrid),100.f,100.f,0,0,1,1);
BackgroundLayer * backgroundLayer = new BackgroundLayer(Renderer::screenWidth,Renderer::screenHeight);
backgroundLayer->addElement(this->spriteGrid,100,100);
this->backgroundManager.addLayer(backgroundLayer);
unsigned int * pixelsStarfield = (unsigned int*)calloc(sizeof(unsigned int), 100 * 100);
TextureGenerator::generateStarfield(pixelsStarfield,100,100,10);
backgroundLayer = new BackgroundLayer(Renderer::screenWidth,Renderer::screenHeight,0.0,-1.5f);
backgroundLayer->addElement(new Sprite(new Texture(100,100,(unsigned char*)pixelsStarfield),100.f,100.f,0,0,1,1),100,100);
this->backgroundManager.addLayer(backgroundLayer);
unsigned int * pixelsStarfield2 = (unsigned int*)calloc(sizeof(unsigned int), 100 * 100);
TextureGenerator::generateStarfield(pixelsStarfield2,100,100,10);
backgroundLayer = new BackgroundLayer(Renderer::screenWidth,Renderer::screenHeight,0.0,-1.0f);
backgroundLayer->addElement(new Sprite(new Texture(100,100,(unsigned char*)pixelsStarfield2),100.f,100.f,0,0,1,1),100,100);
this->backgroundManager.addLayer(backgroundLayer);
}
// Does not account for converting luminance...
SDL_Surface * ILAPIENTRY ilutConvertToSDLSurface(unsigned int flags)
{
SDL_Surface *Bitmap;
ILuint i = 0, Pad, BppPal;
ILubyte *Dest;
ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
InitSDL();
// Should be IL_BGR(A).
if (ilutCurImage->Format == IL_RGB || ilutCurImage->Format == IL_RGBA) {
if (!isBigEndian)
iluSwapColours();
}
if (ilutCurImage->Origin == IL_ORIGIN_LOWER_LEFT)
iluFlipImage();
if (ilutCurImage->Type > IL_UNSIGNED_BYTE) {} // Can't do anything about this right now...
if (ilutCurImage->Type == IL_BYTE) {} // Can't do anything about this right now...
Bitmap = SDL_CreateRGBSurface(flags,ilutCurImage->Width,ilutCurImage->Height,ilutCurImage->Bpp * 8,
rmask,gmask,bmask,amask);
if (Bitmap == NULL) {
return IL_FALSE;
}
if (SDL_MUSTLOCK(Bitmap))
SDL_LockSurface(Bitmap);
Pad = Bitmap->pitch - ilutCurImage->Bps;
if (Pad == 0) {
memcpy(Bitmap->pixels, ilutCurImage->Data, ilutCurImage->SizeOfData);
}
else { // Must pad the lines on some images.
Dest = Bitmap->pixels;
for (i = 0; i < ilutCurImage->Height; i++) {
memcpy(Dest, ilutCurImage->Data + i * ilutCurImage->Bps, ilutCurImage->Bps);
imemclear(Dest + ilutCurImage->Bps, Pad);
Dest += Bitmap->pitch;
}
}
if (SDL_MUSTLOCK(Bitmap))
SDL_UnlockSurface(Bitmap);
if (ilutCurImage->Bpp == 1) {
BppPal = ilGetBppPal(ilutCurImage->Pal.PalType);
switch (ilutCurImage->Pal.PalType)
{
case IL_PAL_RGB24:
case IL_PAL_RGB32:
case IL_PAL_RGBA32:
for (i = 0; i < ilutCurImage->Pal.PalSize / BppPal; i++) {
(Bitmap->format)->palette->colors[i].r = ilutCurImage->Pal.Palette[i*BppPal+0];
(Bitmap->format)->palette->colors[i].g = ilutCurImage->Pal.Palette[i*BppPal+1];
(Bitmap->format)->palette->colors[i].b = ilutCurImage->Pal.Palette[i*BppPal+2];
(Bitmap->format)->palette->colors[i].unused = 255;
}
break;
case IL_PAL_BGR24:
case IL_PAL_BGR32:
case IL_PAL_BGRA32:
for (i = 0; i < ilutCurImage->Pal.PalSize / BppPal; i++) {
(Bitmap->format)->palette->colors[i].b = ilutCurImage->Pal.Palette[i*BppPal+0];
(Bitmap->format)->palette->colors[i].g = ilutCurImage->Pal.Palette[i*BppPal+1];
(Bitmap->format)->palette->colors[i].r = ilutCurImage->Pal.Palette[i*BppPal+2];
(Bitmap->format)->palette->colors[i].unused = 255;
}
break;
default:
ilSetError(IL_INTERNAL_ERROR); // Do anything else?
}
}
return Bitmap;
}
GLuint Graphic::SDL_GL_LoadTexture( SDL_Surface *surface, GLfloat *texcoord ) {
GLuint tex;
int w, h;
SDL_Surface *image;
SDL_Rect area;
SDL_BlendMode saved_mode;
/* Use the surface width and height expanded to powers of 2 */
w = power_of_two(surface->w);
h = power_of_two(surface->h);
texcoord[0] = 0.0f; /* Min X */
texcoord[1] = 0.0f; /* Min Y */
texcoord[2] = (GLfloat)surface->w / w; /* Max X */
texcoord[3] = (GLfloat)surface->h / h; /* Max Y */
image = SDL_CreateRGBSurface(
SDL_SWSURFACE,
w, h,
32,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000
#else
0xFF000000,
0x00FF0000,
0x0000FF00,
0x000000FF
#endif
);
if ( image == NULL ) {
return 0;
}
SDL_GetSurfaceBlendMode(surface, &saved_mode);
SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_NONE);
/* Copy the surface into the GL texture image */
area.x = 0;
area.y = 0;
area.w = surface->w;
area.h = surface->h;
SDL_BlitSurface(surface, &area, image, &area);
SDL_SetSurfaceBlendMode(surface, saved_mode);
/* Create an OpenGL texture for the image */
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGBA,
w, h,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
image->pixels);
SDL_FreeSurface(image); /* No longer needed */
return tex;
}
/* Load a XPM type image from an SDL datasource */
SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src)
{
SDL_Surface *image;
char line[1024];
char *here;
int index;
int x, y;
int w, h, ncolors, cpp;
int pixels_len;
char *pixels = NULL;
int indexed;
Uint8 *dst;
struct color_hash *colors;
SDL_Color *im_colors = NULL;
char *keystrings, *nextkey;
char *error = NULL;
/* Skip to the first string, which describes the image */
do {
here = SDL_RWgets(line, sizeof(line), src);
if ( !here ) {
IMG_SetError("Premature end of data");
return(NULL);
}
here = skipspace(here);
} while(*here != '"');
/*
* The header string of an XPMv3 image has the format
*
* <width> <height> <ncolors> <cpp> [ <hotspot_x> <hotspot_y> ]
*
* where the hotspot coords are intended for mouse cursors.
* Right now we don't use the hotspots but it should be handled
* one day.
*/
if(sscanf(here + 1, "%d %d %d %d", &w, &h, &ncolors, &cpp) != 4
|| w <= 0 || h <= 0 || ncolors <= 0 || cpp <= 0) {
IMG_SetError("Invalid format description");
return(NULL);
}
keystrings = malloc(ncolors * cpp);
if(!keystrings) {
IMG_SetError("Out of memory");
free(pixels);
return NULL;
}
nextkey = keystrings;
/* Create the new surface */
if(ncolors <= 256) {
indexed = 1;
image = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 8,
0, 0, 0, 0);
im_colors = image->format->palette->colors;
image->format->palette->ncolors = ncolors;
} else {
indexed = 0;
image = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32,
0xff0000, 0x00ff00, 0x0000ff, 0);
}
if(!image) {
/* Hmm, some SDL error (out of memory?) */
free(pixels);
return(NULL);
}
/* Read the colors */
colors = create_colorhash(ncolors);
if ( ! colors ) {
error = "Out of memory";
goto done;
}
for(index = 0; index < ncolors; ++index ) {
char *key;
int len;
do {
here = SDL_RWgets(line, sizeof(line), src);
if(!here) {
error = "Premature end of data";
goto done;
}
here = skipspace(here);
} while(*here != '"');
++here;
len = strlen(here);
if(len < cpp + 7)
continue; /* cannot be a valid line */
key = here;
key[cpp] = '\0';
here += cpp + 1;
/* parse a colour definition */
for(;;) {
char nametype;
char *colname;
char delim;
Uint32 rgb;
here = skipspace(here);
nametype = *here;
here = skipnonspace(here);
here = skipspace(here);
colname = here;
while(*here && !isspace((unsigned char)*here)
&& *here != '"')
here++;
if(!*here) {
error = "color parse error";
goto done;
}
if(nametype == 's')
continue; /* skip symbolic colour names */
delim = *here;
*here = '\0';
if(delim)
here++;
if(!color_to_rgb(colname, &rgb))
continue;
memcpy(nextkey, key, cpp);
if(indexed) {
SDL_Color *c = im_colors + index;
c->r = rgb >> 16;
c->g = rgb >> 8;
c->b = rgb;
add_colorhash(colors, nextkey, cpp, index);
} else
add_colorhash(colors, nextkey, cpp, rgb);
nextkey += cpp;
if(rgb == 0xffffffff)
SDL_SetColorKey(image, SDL_SRCCOLORKEY,
indexed ? index : rgb);
break;
}
}
int main(int argc, char** argv)
{
srand(time(NULL));
struct chip8 cpu;
initialize(&cpu);
load_game(&cpu, argv[1]);
//setup graphics
SDL_Window *window = NULL;
SDL_Surface *screen = NULL;
if(SDL_Init(SDL_INIT_VIDEO) < 0)
{
printf( "SDL could not initialize! SDL_Error: %s\n", SDL_GetError() );
}
else
{
window = SDL_CreateWindow( "Chip8", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
if(!window)
{
printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
}
else
{
//Get window surface
screen = SDL_GetWindowSurface(window);
//Fill the surface white
SDL_FillRect( screen, NULL, SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF ) );
//Update the surface
SDL_UpdateWindowSurface(window);
}
}
SDL_Surface *s;
s = SDL_CreateRGBSurface(0, 640, 320, 32, 0,0,0,0);
SDL_FillRect(s, NULL, SDL_MapRGB(s->format, 0, 0, 0));
SDL_Surface *pixel = NULL;
pixel = SDL_LoadBMP("pixel.bmp");
if(!pixel)
{
printf( "Unable to load image! SDL Error: %s\n", SDL_GetError() );
}
SDL_BlitSurface(s, NULL, screen, NULL);
SDL_BlitSurface(pixel, NULL, screen, NULL);
SDL_UpdateWindowSurface(window);
//init keys
reset_keys(&cpu);
int quit = 0;
while(!quit)
{
usleep(1000);
emulate_cycle(&cpu);
if(cpu.drawFlag)
{
//draw graphics
SDL_BlitSurface(s, NULL, screen, NULL);
for(int i = 0; i < DISP_T; i++)
{
if(cpu.gfx[i])
{
int x = (i % 64) * 10;
int y = (i / 64) *10;
SDL_Rect r;
r.x = x;
r.y = y;
r.w = 10;
r.h = 10;
SDL_BlitSurface(pixel, NULL, screen, &r);
}
}
SDL_UpdateWindowSurface(window);
cpu.drawFlag = 0;
}
//set keys
reset_keys(&cpu);
SDL_Event e;
SDL_PollEvent(&e);
if(e.type == SDL_QUIT) {
quit = 1;
} else if(e.type == SDL_KEYDOWN) {
long k = e.key.keysym.sym;
switch(k) {
case SDLK_1:
cpu.keys[0] = 1;
break;
case SDLK_2:
cpu.keys[1] = 1;
break;
case SDLK_3:
cpu.keys[2] = 1;
break;
case SDLK_4:
cpu.keys[3] = 1;
break;
case SDLK_q:
cpu.keys[4] = 1;
break;
case SDLK_w:
cpu.keys[5] = 1;
break;
case SDLK_e:
cpu.keys[6] = 1;
break;
case SDLK_r:
cpu.keys[7] = 1;
break;
case SDLK_a:
cpu.keys[8] = 1;
break;
case SDLK_s:
cpu.keys[9] = 1;
break;
case SDLK_d:
cpu.keys[10] = 1;
break;
case SDLK_f:
cpu.keys[11] = 1;
break;
case SDLK_z:
cpu.keys[12] = 1;
break;
case SDLK_x:
cpu.keys[13] = 1;
break;
case SDLK_c:
cpu.keys[14] = 1;
break;
case SDLK_v:
cpu.keys[15] = 1;
break;
}
}
}
SDL_FreeSurface(s);
SDL_FreeSurface(pixel);
pixel = NULL;
SDL_DestroyWindow(window);
SDL_DestroyWindow(screen);
SDL_Quit();
return 0;
}
int gui_init (void)
{
//Se ejecuta justo despues del MAIN
if (prSDLScreen==NULL)
#ifdef DREAMCAST
prSDLScreen=SDL_SetVideoMode(320,240,16,VIDEO_FLAGS);
#else
#ifdef PANDORA
if(hwScaled)
prSDLScreen = SDL_SetVideoMode(320, gfxHeight, 16, VIDEO_FLAGS);
else
{
prSDLScreen = SDL_CreateRGBSurface(SDL_SWSURFACE,320,240,16,0,0,0,0);
prSDLScaleScreen = SDL_SetVideoMode(640, 480, 16, VIDEO_FLAGS);
}
#else
prSDLScreen=SDL_SetVideoMode(320,240,16,VIDEO_FLAGS);
#endif
#endif
SDL_ShowCursor(SDL_DISABLE);
SDL_JoystickEventState(SDL_ENABLE);
SDL_JoystickOpen(0);
if (prSDLScreen!=NULL)
{
emulating=0;
#if !defined(DEBUG_UAE4ALL) && !defined(PROFILER_UAE4ALL) && !defined(AUTO_RUN) && !defined(AUTO_FRAMERATE)
//uae4all_image_file[0]=0;
//uae4all_image_file2[0]=0;
#else
//strcpy(uae4all_image_file,"prueba.adz");
//strcpy(uae4all_image_file2,"prueba2.adz");
#endif
init_text(1);
if (!uae4all_image_file0[0])
run_mainMenu();
quit_text();
vkbd_init();
#ifdef GP2X
inputmode_init();
#if !defined(PANDORA) && !defined(GCW0)
volumecontrol_init();
#endif
#endif
printf("4\n");
#if defined (PSP) || defined (GIZMONDO)
inputmode_init();
#endif
uae4all_pause_music();
printf("5\n");
emulating=1;
getChanges();
printf("6\n");
check_all_prefs();
printf("7\n");
reset_frameskip();
printf("8\n");
#ifdef DEBUG_FRAMERATE
uae4all_update_time();
#endif
#ifdef PROFILER_UAE4ALL
uae4all_prof_init();
uae4all_prof_add("M68K"); // 0
uae4all_prof_add("EVENTS"); // 1
uae4all_prof_add("HSync"); // 2
uae4all_prof_add("Copper"); // 3
uae4all_prof_add("Audio"); // 4
uae4all_prof_add("CIA"); // 5
uae4all_prof_add("Blitter"); // 6
uae4all_prof_add("Vsync"); // 7
uae4all_prof_add("update_fetch"); // 8
uae4all_prof_add("linetoscr"); // 9
uae4all_prof_add("do_long_fetch"); // 10
uae4all_prof_add("pfield_doline"); // 11
uae4all_prof_add("draw_sprites_ecs"); // 12
uae4all_prof_add("flush_block"); // 13
uae4all_prof_add("SET_INTERRUPT"); // 14
/*
uae4all_prof_add("15"); // 15
uae4all_prof_add("16"); // 16
uae4all_prof_add("17"); // 17
uae4all_prof_add("18"); // 18
uae4all_prof_add("19"); // 19
uae4all_prof_add("20"); // 20
uae4all_prof_add("21"); // 21
uae4all_prof_add("22"); // 22
*/
#endif
#ifdef DREAMCAST
SDL_DC_EmulateKeyboard(SDL_FALSE);
#endif
/*int test = pnd_evdev_open(pnd_evdev_nub1);
printf("nub1 open: %d\n", test);
test = pnd_evdev_open(pnd_evdev_nub2);
printf("nub2 open: %d\n", test);*/
return 0;
}
return -1;
}
void Draw (SDL_Surface *screen, int start)
{
SDL_Surface *picture, *picture_again;
char *bmpfile;
/* --------- 8 bit test -------- */
if (start<=1) {
/* Message */
fprintf (stderr,"Loading 8bit square image\n");
/* Load the image into a surface */
bmpfile = "sample8-box.bmp";
fprintf(stderr, "Loading picture: %s\n", bmpfile);
picture = SDL_LoadBMP(bmpfile);
if ( picture == NULL ) {
fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
return;
}
fprintf (stderr,"1. shrink 8bit\n");
ShrinkPicture(screen,picture);
/* Free the picture */
SDL_FreeSurface(picture);
}
if (start<=2) {
/* Message */
fprintf (stderr,"Loading 8bit image\n");
/* Load the image into a surface */
bmpfile = "sample8.bmp";
fprintf(stderr, "Loading picture: %s\n", bmpfile);
picture = SDL_LoadBMP(bmpfile);
if ( picture == NULL ) {
fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
return;
}
fprintf (stderr,"1. shrink 8bit\n");
ShrinkPicture(screen,picture);
/* Free the picture */
SDL_FreeSurface(picture);
}
/* -------- 24 bit test --------- */
if (start<=3) {
/* Message */
fprintf (stderr,"Loading 24bit square image\n");
/* Load the image into a surface */
bmpfile = "sample24-box.bmp";
fprintf(stderr, "Loading picture: %s\n", bmpfile);
picture = SDL_LoadBMP(bmpfile);
if ( picture == NULL ) {
fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
return;
}
fprintf (stderr,"2. shrink 24bit\n");
ShrinkPicture(screen,picture);
/* Free the picture */
SDL_FreeSurface(picture);
}
if (start<=4) {
/* Message */
fprintf (stderr,"Loading 24bit image\n");
/* Load the image into a surface */
bmpfile = "sample24.bmp";
fprintf(stderr, "Loading picture: %s\n", bmpfile);
picture = SDL_LoadBMP(bmpfile);
if ( picture == NULL ) {
fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
return;
}
fprintf (stderr,"2. shrink 24bit\n");
ShrinkPicture(screen,picture);
/* Free the picture */
SDL_FreeSurface(picture);
}
/* -------- 32 bit test --------- */
if (start<=5) {
/* Message */
fprintf (stderr,"Loading 24bit square image\n");
/* Load the image into a surface */
bmpfile = "sample24-box.bmp";
fprintf(stderr, "Loading picture: %s\n", bmpfile);
picture = SDL_LoadBMP(bmpfile);
if ( picture == NULL ) {
fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
return;
}
/* New source surface is 32bit with defined RGBA ordering */
/* Much faster to do this once rather than the routine on the fly */
fprintf (stderr,"Converting 24bit image into 32bit RGBA surface ...\n");
picture_again = SDL_CreateRGBSurface(SDL_SWSURFACE, picture->w, picture->h, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
SDL_BlitSurface(picture,NULL,picture_again,NULL);
/* Message */
fprintf (stderr,"3. shrink 32bit \n");
ShrinkPicture(screen,picture_again);
/* Free the picture2 */
SDL_FreeSurface(picture_again);
SDL_FreeSurface(picture);
}
if (start<=6) {
/* Message */
fprintf (stderr,"Loading 24bit image\n");
/* Load the image into a surface */
bmpfile = "sample24.bmp";
fprintf(stderr, "Loading picture: %s\n", bmpfile);
picture = SDL_LoadBMP(bmpfile);
if ( picture == NULL ) {
fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
return;
}
/* New source surface is 32bit with defined RGBA ordering */
/* Much faster to do this once rather than the routine on the fly */
fprintf (stderr,"Converting 24bit image into 32bit RGBA surface ...\n");
picture_again = SDL_CreateRGBSurface(SDL_SWSURFACE, picture->w, picture->h, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
SDL_BlitSurface(picture,NULL,picture_again,NULL);
/* Message */
fprintf (stderr,"3. shrink 32bit \n");
ShrinkPicture(screen,picture_again);
/* Free the picture2 */
SDL_FreeSurface(picture_again);
SDL_FreeSurface(picture);
}
return;
}
void CGX_SetIcon(_THIS, SDL_Surface *icon, Uint8 *mask)
{
#if 0
SDL_Surface *sicon;
XWMHints *wmhints;
XImage *icon_image;
Pixmap icon_pixmap;
Pixmap mask_pixmap;
#ifdef USE_ICON_WINDOW
Window icon_window;
#endif
GC GC;
XGCValues GCvalues;
int i, b, dbpp;
SDL_Rect bounds;
Uint8 *LSBmask, *color_tried;
Visual *dvis;
/* Lock the event thread, in multi-threading environments */
SDL_Lock_EventThread();
/* The icon must use the default visual, depth and colormap of the
screen, so it might need a conversion */
dbpp = DefaultDepth(SDL_Display, SDL_Screen);
switch(dbpp) {
case 15:
dbpp = 16; break;
case 24:
dbpp = 32; break;
}
dvis = DefaultVisual(SDL_Display, SDL_Screen);
/* The Visual struct is supposed to be opaque but we cheat a little */
sicon = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
dbpp,
dvis->red_mask, dvis->green_mask,
dvis->blue_mask, 0);
if ( sicon == NULL ) {
goto done;
}
/* If we already have allocated colours from the default colormap,
copy them */
if(SDL_Visual == dvis && SDL_XColorMap == SDL_DisplayColormap
&& this->screen->format->palette && sicon->format->palette) {
memcpy(sicon->format->palette->colors,
this->screen->format->palette->colors,
this->screen->format->palette->ncolors * sizeof(SDL_Color));
}
bounds.x = 0;
bounds.y = 0;
bounds.w = icon->w;
bounds.h = icon->h;
if ( SDL_LowerBlit(icon, &bounds, sicon, &bounds) < 0 )
goto done;
/* Lock down the colors used in the colormap */
color_tried = NULL;
if ( sicon->format->BitsPerPixel == 8 ) {
SDL_Palette *palette;
Uint8 *p;
XColor wanted;
palette = sicon->format->palette;
color_tried = malloc(palette->ncolors);
if ( color_tried == NULL ) {
goto done;
}
if ( SDL_iconcolors != NULL ) {
free(SDL_iconcolors);
}
SDL_iconcolors = malloc(palette->ncolors
* sizeof(*SDL_iconcolors));
if ( SDL_iconcolors == NULL ) {
free(color_tried);
goto done;
}
memset(color_tried, 0, palette->ncolors);
memset(SDL_iconcolors, 0,
palette->ncolors * sizeof(*SDL_iconcolors));
p = (Uint8 *)sicon->pixels;
for ( i = sicon->w*sicon->h; i > 0; --i, ++p ) {
if ( ! color_tried[*p] ) {
wanted.pixel = *p;
wanted.red = (palette->colors[*p].r<<8);
wanted.green = (palette->colors[*p].g<<8);
wanted.blue = (palette->colors[*p].b<<8);
wanted.flags = (DoRed|DoGreen|DoBlue);
if (XAllocColor(SDL_Display,
SDL_DisplayColormap, &wanted)) {
++SDL_iconcolors[wanted.pixel];
}
color_tried[*p] = 1;
}
}
}
if ( color_tried != NULL ) {
free(color_tried);
}
/* Translate mask data to LSB order and set the icon mask */
i = (sicon->w/8)*sicon->h;
LSBmask = (Uint8 *)malloc(i);
if ( LSBmask == NULL ) {
goto done;
}
memset(LSBmask, 0, i);
while ( --i >= 0 ) {
for ( b=0; b<8; ++b )
LSBmask[i] |= (((mask[i]>>b)&0x01)<<(7-b));
}
mask_pixmap = XCreatePixmapFromBitmapData(SDL_Display, WMwindow,
LSBmask, sicon->w, sicon->h, 1L, 0L, 1);
/* Transfer the image to an X11 pixmap */
icon_image = XCreateImage(SDL_Display,
DefaultVisual(SDL_Display, SDL_Screen),
DefaultDepth(SDL_Display, SDL_Screen),
ZPixmap, 0, (char *)sicon->pixels, sicon->w, sicon->h,
((sicon->format)->BytesPerPixel == 3) ? 32 :
(sicon->format)->BytesPerPixel*8, 0);
icon_pixmap = XCreatePixmap(SDL_Display, SDL_Root, sicon->w, sicon->h,
DefaultDepth(SDL_Display, SDL_Screen));
GC = XCreateGC(SDL_Display, icon_pixmap, 0, &GCvalues);
XPutImage(SDL_Display, icon_pixmap, GC, icon_image,
0, 0, 0, 0, sicon->w, sicon->h);
XFreeGC(SDL_Display, GC);
XDestroyImage(icon_image);
free(LSBmask);
sicon->pixels = NULL;
#ifdef USE_ICON_WINDOW
/* Create an icon window and set the pixmap as its background */
icon_window = XCreateSimpleWindow(SDL_Display, SDL_Root,
0, 0, sicon->w, sicon->h, 0,
CopyFromParent, CopyFromParent);
XSetWindowBackgroundPixmap(SDL_Display, icon_window, icon_pixmap);
XClearWindow(SDL_Display, icon_window);
#endif
/* Set the window icon to the icon pixmap (and icon window) */
wmhints = XAllocWMHints();
wmhints->flags = (IconPixmapHint | IconMaskHint);
wmhints->icon_pixmap = icon_pixmap;
wmhints->icon_mask = mask_pixmap;
#ifdef USE_ICON_WINDOW
wmhints->flags |= IconWindowHint;
wmhints->icon_window = icon_window;
#endif
XSetWMHints(SDL_Display, WMwindow, wmhints);
XFree(wmhints);
XSync(SDL_Display, False);
done:
SDL_Unlock_EventThread();
if ( sicon != NULL ) {
SDL_FreeSurface(sicon);
}
#endif
return;
}
/*
* Convert a surface into the specified pixel format.
*/
SDL_Surface *
SDL_ConvertSurface(SDL_Surface * surface, const SDL_PixelFormat * format,
Uint32 flags)
{
SDL_Surface *convert;
Uint32 copy_flags;
SDL_Color copy_color;
SDL_Rect bounds;
/* Check for empty destination palette! (results in empty image) */
if (format->palette != NULL) {
int i;
for (i = 0; i < format->palette->ncolors; ++i) {
if ((format->palette->colors[i].r != 0xFF) ||
(format->palette->colors[i].g != 0xFF) ||
(format->palette->colors[i].b != 0xFF))
break;
}
if (i == format->palette->ncolors) {
SDL_SetError("Empty destination palette");
return (NULL);
}
}
/* Create a new surface with the desired format */
convert = SDL_CreateRGBSurface(flags, surface->w, surface->h,
format->BitsPerPixel, format->Rmask,
format->Gmask, format->Bmask,
format->Amask);
if (convert == NULL) {
return (NULL);
}
/* Copy the palette if any */
if (format->palette && convert->format->palette) {
SDL_memcpy(convert->format->palette->colors,
format->palette->colors,
format->palette->ncolors * sizeof(SDL_Color));
convert->format->palette->ncolors = format->palette->ncolors;
}
/* Save the original copy flags */
copy_flags = surface->map->info.flags;
copy_color.r = surface->map->info.r;
copy_color.g = surface->map->info.g;
copy_color.b = surface->map->info.b;
copy_color.a = surface->map->info.a;
surface->map->info.r = 0xFF;
surface->map->info.g = 0xFF;
surface->map->info.b = 0xFF;
surface->map->info.a = 0xFF;
surface->map->info.flags = 0;
SDL_InvalidateMap(surface->map);
/* Copy over the image data */
bounds.x = 0;
bounds.y = 0;
bounds.w = surface->w;
bounds.h = surface->h;
SDL_LowerBlit(surface, &bounds, convert, &bounds);
/* Clean up the original surface, and update converted surface */
convert->map->info.r = copy_color.r;
convert->map->info.g = copy_color.g;
convert->map->info.b = copy_color.b;
convert->map->info.a = copy_color.a;
convert->map->info.flags =
(copy_flags &
~(SDL_COPY_COLORKEY | SDL_COPY_BLEND
| SDL_COPY_RLE_DESIRED | SDL_COPY_RLE_COLORKEY |
SDL_COPY_RLE_ALPHAKEY));
surface->map->info.r = copy_color.r;
surface->map->info.g = copy_color.g;
surface->map->info.b = copy_color.b;
surface->map->info.a = copy_color.a;
surface->map->info.flags = copy_flags;
SDL_InvalidateMap(surface->map);
if (copy_flags & SDL_COPY_COLORKEY) {
SDL_bool set_colorkey_by_color = SDL_FALSE;
if (surface->format->palette) {
if (format->palette &&
surface->format->palette->ncolors <= format->palette->ncolors &&
(SDL_memcmp(surface->format->palette->colors, format->palette->colors,
surface->format->palette->ncolors * sizeof(SDL_Color)) == 0)) {
/* The palette is identical, just set the same colorkey */
SDL_SetColorKey(convert, 1, surface->map->info.colorkey);
} else if (format->Amask) {
/* The alpha was set in the destination from the palette */
} else {
set_colorkey_by_color = SDL_TRUE;
}
} else {
set_colorkey_by_color = SDL_TRUE;
}
if (set_colorkey_by_color) {
/* Set the colorkey by color, which needs to be unique */
Uint8 keyR, keyG, keyB, keyA;
SDL_GetRGBA(surface->map->info.colorkey, surface->format, &keyR,
&keyG, &keyB, &keyA);
SDL_SetColorKey(convert, 1,
SDL_MapRGBA(convert->format, keyR, keyG, keyB, keyA));
/* This is needed when converting for 3D texture upload */
SDL_ConvertColorkeyToAlpha(convert);
}
}
SDL_SetClipRect(convert, &surface->clip_rect);
/* Enable alpha blending by default if the new surface has an
* alpha channel or alpha modulation */
if ((surface->format->Amask && format->Amask) ||
(copy_flags & (SDL_COPY_COLORKEY|SDL_COPY_MODULATE_ALPHA))) {
SDL_SetSurfaceBlendMode(convert, SDL_BLENDMODE_BLEND);
}
if ((copy_flags & SDL_COPY_RLE_DESIRED) || (flags & SDL_RLEACCEL)) {
SDL_SetSurfaceRLE(convert, SDL_RLEACCEL);
}
/* We're ready to go! */
return (convert);
}
BATTLERESULT
PAL_StartBattle(
WORD wEnemyTeam,
BOOL fIsBoss
)
/*++
Purpose:
Start a battle.
Parameters:
[IN] wEnemyTeam - the number of the enemy team.
[IN] fIsBoss - TRUE for boss fight (not allowed to flee).
Return value:
The result of the battle.
--*/
{
int i;
WORD w, wPrevWaveLevel;
SHORT sPrevWaveProgression;
UTIL_WriteLog(LOG_DEBUG, "[0x%08x][%s][%s] - [%d],[%d]", (long)PAL_StartBattle, "PAL_StartBattle", __FILE__, wEnemyTeam, fIsBoss);
//
// Set the screen waving effects
//
wPrevWaveLevel = gpGlobals->wScreenWave;
sPrevWaveProgression = gpGlobals->sWaveProgression;
gpGlobals->sWaveProgression = 0;
gpGlobals->wScreenWave = gpGlobals->g.lprgBattleField[gpGlobals->wNumBattleField].wScreenWave;
//
// Make sure everyone in the party is alive, also clear all hidden
// EXP count records
//
for (i = 0; i <= gpGlobals->wMaxPartyMemberIndex; i++)
{
w = gpGlobals->rgParty[i].wPlayerRole;
if (gpGlobals->g.PlayerRoles.rgwHP[w] == 0)
{
gpGlobals->g.PlayerRoles.rgwHP[w] = 1;
gpGlobals->rgPlayerStatus[w][kStatusPuppet] = 0;
}
gpGlobals->Exp.rgHealthExp[w].wCount = 0;
gpGlobals->Exp.rgMagicExp[w].wCount = 0;
gpGlobals->Exp.rgAttackExp[w].wCount = 0;
gpGlobals->Exp.rgMagicPowerExp[w].wCount = 0;
gpGlobals->Exp.rgDefenseExp[w].wCount = 0;
gpGlobals->Exp.rgDexterityExp[w].wCount = 0;
gpGlobals->Exp.rgFleeExp[w].wCount = 0;
}
//
// Clear all item-using records
//
for (i = 0; i < MAX_INVENTORY; i++)
{
gpGlobals->rgInventory[i].nAmountInUse = 0;
}
//
// Store all enemies
//
for (i = 0; i < MAX_ENEMIES_IN_TEAM; i++)
{
memset(&(g_Battle.rgEnemy[i]), 0, sizeof(BATTLEENEMY));
w = gpGlobals->g.lprgEnemyTeam[wEnemyTeam].rgwEnemy[i];
if (w == 0xFFFF)
{
break;
}
if (w != 0)
{
g_Battle.rgEnemy[i].e = gpGlobals->g.lprgEnemy[gpGlobals->g.rgObject[w].enemy.wEnemyID];
g_Battle.rgEnemy[i].wObjectID = w;
g_Battle.rgEnemy[i].state = kFighterWait;
g_Battle.rgEnemy[i].wScriptOnTurnStart = gpGlobals->g.rgObject[w].enemy.wScriptOnTurnStart;
g_Battle.rgEnemy[i].wScriptOnBattleEnd = gpGlobals->g.rgObject[w].enemy.wScriptOnBattleEnd;
g_Battle.rgEnemy[i].wScriptOnReady = gpGlobals->g.rgObject[w].enemy.wScriptOnReady;
g_Battle.rgEnemy[i].iColorShift = 0;
#ifndef PAL_CLASSIC
g_Battle.rgEnemy[i].flTimeMeter = 50;
//
// HACK: Otherwise the black thief lady will be too hard to beat
//
if (g_Battle.rgEnemy[i].e.wDexterity == 164)
{
g_Battle.rgEnemy[i].e.wDexterity /= ((gpGlobals->wMaxPartyMemberIndex == 0) ? 6 : 3);
}
//
// HACK: Heal up automatically for final boss
//
if (g_Battle.rgEnemy[i].e.wHealth == 32760)
{
for (w = 0; w < MAX_PLAYER_ROLES; w++)
{
gpGlobals->g.PlayerRoles.rgwHP[w] = gpGlobals->g.PlayerRoles.rgwMaxHP[w];
gpGlobals->g.PlayerRoles.rgwMP[w] = gpGlobals->g.PlayerRoles.rgwMaxMP[w];
}
}
//
// Yet another HACKs
//
if ((SHORT)g_Battle.rgEnemy[i].e.wDexterity == -32)
{
g_Battle.rgEnemy[i].e.wDexterity = 0; // for Grandma Knife
}
else if (g_Battle.rgEnemy[i].e.wDexterity == 20)
{
//
// for Fox Demon
//
if (gpGlobals->g.PlayerRoles.rgwLevel[0] < 15)
{
g_Battle.rgEnemy[i].e.wDexterity = 8;
}
else if (gpGlobals->g.PlayerRoles.rgwLevel[4] > 28 ||
gpGlobals->Exp.rgPrimaryExp[4].wExp > 0)
{
g_Battle.rgEnemy[i].e.wDexterity = 60;
}
}
else if (g_Battle.rgEnemy[i].e.wExp == 250 &&
g_Battle.rgEnemy[i].e.wCash == 1100)
{
g_Battle.rgEnemy[i].e.wDexterity += 12; // for Snake Demon
}
else if ((SHORT)g_Battle.rgEnemy[i].e.wDexterity == -60)
{
g_Battle.rgEnemy[i].e.wDexterity = 15; // for Spider
}
else if ((SHORT)g_Battle.rgEnemy[i].e.wDexterity == -30)
{
g_Battle.rgEnemy[i].e.wDexterity = (WORD)-10; // for Stone Head
}
else if ((SHORT)g_Battle.rgEnemy[i].e.wDexterity == -16)
{
g_Battle.rgEnemy[i].e.wDexterity = 0; // for Zombie
}
else if ((SHORT)g_Battle.rgEnemy[i].e.wDexterity == -20)
{
g_Battle.rgEnemy[i].e.wDexterity = -8; // for Flower Demon
}
else if (g_Battle.rgEnemy[i].e.wLevel < 20 &&
gpGlobals->wNumScene >= 0xD8 && gpGlobals->wNumScene <= 0xE2)
{
//
// for low-level monsters in the Cave of Trial
//
g_Battle.rgEnemy[i].e.wLevel += 15;
g_Battle.rgEnemy[i].e.wDexterity += 25;
}
else if (gpGlobals->wNumScene == 0x90)
{
g_Battle.rgEnemy[i].e.wDexterity += 25; // for Tower Dragons
}
else if (g_Battle.rgEnemy[i].e.wLevel == 2 &&
g_Battle.rgEnemy[i].e.wCash == 48)
{
g_Battle.rgEnemy[i].e.wDexterity += 8; // for Miao Fists
}
else if (g_Battle.rgEnemy[i].e.wLevel == 4 &&
g_Battle.rgEnemy[i].e.wCash == 240)
{
g_Battle.rgEnemy[i].e.wDexterity += 18; // for Fat Miao
}
else if (g_Battle.rgEnemy[i].e.wLevel == 16 &&
g_Battle.rgEnemy[i].e.wMagicRate == 4 &&
g_Battle.rgEnemy[i].e.wAttackEquivItemRate == 4)
{
g_Battle.rgEnemy[i].e.wDexterity += 50; // for Black Spider
}
#endif
}
}
g_Battle.wMaxEnemyIndex = i - 1;
//
// Store all players
//
for (i = 0; i <= gpGlobals->wMaxPartyMemberIndex; i++)
{
g_Battle.rgPlayer[i].flTimeMeter = 15.0f;
#ifndef PAL_CLASSIC
g_Battle.rgPlayer[i].flTimeSpeedModifier = 2.0f;
g_Battle.rgPlayer[i].sTurnOrder = -1;
#endif
g_Battle.rgPlayer[i].wHidingTime = 0;
g_Battle.rgPlayer[i].state = kFighterWait;
g_Battle.rgPlayer[i].action.sTarget = -1;
g_Battle.rgPlayer[i].fDefending = FALSE;
g_Battle.rgPlayer[i].wCurrentFrame = 0;
g_Battle.rgPlayer[i].iColorShift = FALSE;
}
//
// Load sprites and background
//
PAL_LoadBattleSprites();
PAL_LoadBattleBackground();
//
// Create the surface for scene buffer
//
g_Battle.lpSceneBuf =
SDL_CreateRGBSurface(gpScreen->flags & ~SDL_HWSURFACE, 320, 200, 8,
gpScreen->format->Rmask, gpScreen->format->Gmask,
gpScreen->format->Bmask, gpScreen->format->Amask);
if (g_Battle.lpSceneBuf == NULL)
{
TerminateOnError("PAL_StartBattle(): creating surface for scene buffer failed!");
}
PAL_UpdateEquipments();
g_Battle.iExpGained = 0;
g_Battle.iCashGained = 0;
g_Battle.fIsBoss = fIsBoss;
g_Battle.fEnemyCleared = FALSE;
g_Battle.fEnemyMoving = FALSE;
g_Battle.iHidingTime = 0;
g_Battle.wMovingPlayerIndex = 0;
g_Battle.UI.szMsg[0] = '\0';
g_Battle.UI.szNextMsg[0] = '\0';
g_Battle.UI.dwMsgShowTime = 0;
g_Battle.UI.state = kBattleUIWait;
g_Battle.UI.fAutoAttack = FALSE;
g_Battle.UI.wSelectedIndex = 0;
g_Battle.UI.wPrevEnemyTarget = 0;
memset(g_Battle.UI.rgShowNum, 0, sizeof(g_Battle.UI.rgShowNum));
g_Battle.lpSummonSprite = NULL;
g_Battle.sBackgroundColorShift = 0;
gpGlobals->fInBattle = TRUE;
g_Battle.BattleResult = kBattleResultPreBattle;
PAL_BattleUpdateFighters();
//
// Load the battle effect sprite.
//
i = PAL_MKFGetChunkSize(10, gpGlobals->f.fpDATA);
g_Battle.lpEffectSprite = UTIL_malloc(i);
PAL_MKFReadChunk(g_Battle.lpEffectSprite, i, 10, gpGlobals->f.fpDATA);
#ifdef PAL_CLASSIC
g_Battle.Phase = kBattlePhaseSelectAction;
g_Battle.fRepeat = FALSE;
g_Battle.fForce = FALSE;
g_Battle.fFlee = FALSE;
#endif
#ifdef PAL_ALLOW_KEYREPEAT
SDL_EnableKeyRepeat(120, 75);
#endif
//
// Run the main battle routine.
//
i = PAL_BattleMain();
#ifdef PAL_ALLOW_KEYREPEAT
SDL_EnableKeyRepeat(0, 0);
PAL_ClearKeyState();
g_InputState.prevdir = kDirUnknown;
#endif
if (i == kBattleResultWon)
{
//
// Player won the battle. Add the Experience points.
//
PAL_BattleWon();
}
//
// Clear all item-using records
//
for (w = 0; w < MAX_INVENTORY; w++)
{
gpGlobals->rgInventory[w].nAmountInUse = 0;
}
//
// Clear all player status, poisons and temporary effects
//
PAL_ClearAllPlayerStatus();
for (w = 0; w < MAX_PLAYER_ROLES; w++)
{
PAL_CurePoisonByLevel(w, 3);
PAL_RemoveEquipmentEffect(w, kBodyPartExtra);
}
//
// Free all the battle sprites
//
PAL_FreeBattleSprites();
free(g_Battle.lpEffectSprite);
//
// Free the surfaces for the background picture and scene buffer
//
SDL_FreeSurface(g_Battle.lpBackground);
SDL_FreeSurface(g_Battle.lpSceneBuf);
g_Battle.lpBackground = NULL;
g_Battle.lpSceneBuf = NULL;
gpGlobals->fInBattle = FALSE;
RIX_Play(gpGlobals->wNumMusic, TRUE, 1);
//
// Restore the screen waving effects
//
gpGlobals->sWaveProgression = sPrevWaveProgression;
gpGlobals->wScreenWave = wPrevWaveLevel;
UTIL_WriteLog(LOG_DEBUG, "[0x%08x][%s][%s] - %s", (long)PAL_StartBattle, "PAL_StartBattle", __FILE__, "end");
return i;
}
static DFBResult
sdlAllocateBuffer( CoreSurfacePool *pool,
void *pool_data,
void *pool_local,
CoreSurfaceBuffer *buffer,
CoreSurfaceAllocation *allocation,
void *alloc_data )
{
DFBResult ret;
CoreSurface *surface;
SDLAllocationData *alloc = alloc_data;
D_DEBUG_AT( SDL_Pool, "%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( pool, CoreSurfacePool );
D_MAGIC_ASSERT( buffer, CoreSurfaceBuffer );
surface = buffer->surface;
D_MAGIC_ASSERT( surface, CoreSurface );
if (surface->type & CSTF_LAYER) {
dfb_sdl->screen = NULL; /* clear? */
ret = dfb_sdl_set_video_mode( dfb_sdl_core, &surface->config );
if (ret) {
D_DERROR( ret, "SDL/Surface: dfb_sdl_set_video_mode() failed!\n" );
return ret;
}
D_ASSERT( dfb_sdl->screen != NULL );
if (!dfb_sdl->screen) {
D_ERROR( "SDL/Surface: No screen surface!?\n" );
return DFB_BUG;
}
alloc->sdl_surf = dfb_sdl->screen;
D_DEBUG_AT( SDL_Pool, " -> screen surface %dx%d, %d, 0x%08x, pitch %d\n",
dfb_sdl->screen->w, dfb_sdl->screen->h, dfb_sdl->screen->format->BitsPerPixel,
dfb_sdl->screen->flags, dfb_sdl->screen->pitch );
allocation->flags |= CSALF_ONEFORALL;
}
else {
DFBSurfacePixelFormat format = surface->config.format;
Uint32 flags = SDL_HWSURFACE;// | SDL_ASYNCBLIT | SDL_FULLSCREEN;
Uint32 rmask;
Uint32 gmask;
Uint32 bmask;
Uint32 amask;
if (surface->config.caps & DSCAPS_FLIPPING)
flags |= SDL_DOUBLEBUF;
switch (format) {
case DSPF_A8:
rmask = 0x00;
gmask = 0x00;
bmask = 0x00;
amask = 0xff;
break;
case DSPF_RGB16:
rmask = 0xf800;
gmask = 0x07e0;
bmask = 0x001f;
amask = 0x0000;
break;
case DSPF_RGB32:
rmask = 0x00ff0000;
gmask = 0x0000ff00;
bmask = 0x000000ff;
amask = 0x00000000;
break;
case DSPF_ARGB:
rmask = 0x00ff0000;
gmask = 0x0000ff00;
bmask = 0x000000ff;
amask = 0xff000000;
break;
default:
D_ERROR( "SDL/Surface: %s() has no support for %s!\n",
__FUNCTION__, dfb_pixelformat_name(format) );
return DFB_UNSUPPORTED;
}
D_DEBUG_AT( SDL_Pool, " -> SDL_CreateRGBSurface( 0x%08x, "
"%dx%d, %d, 0x%08x, 0x%08x, 0x%08x, 0x%08x )\n",
flags, surface->config.size.w, surface->config.size.h,
DFB_BITS_PER_PIXEL(format), rmask, gmask, bmask, amask );
alloc->sdl_surf = SDL_CreateRGBSurface( flags,
surface->config.size.w,
surface->config.size.h,
DFB_BITS_PER_PIXEL(format),
rmask, gmask, bmask, amask );
if (!alloc->sdl_surf) {
D_ERROR( "SDL/Surface: SDL_CreateRGBSurface( 0x%08x, "
"%dx%d, %d, 0x%08x, 0x%08x, 0x%08x, 0x%08x ) failed!\n",
flags, surface->config.size.w, surface->config.size.h,
DFB_BITS_PER_PIXEL(format), rmask, gmask, bmask, amask );
return DFB_FAILURE;
}
}
D_MAGIC_SET( alloc, SDLAllocationData );
return DFB_OK;
}
GLuint RenderManagerGL2D::loadTexture(SDL_Surface *surface,
bool specular)
{
SDL_Surface* textureSurface;
SDL_Surface* convertedTexture;
textureSurface = surface;
// Determine size of padding for 2^n format
int oldX = textureSurface->w;
int oldY = textureSurface->h;
int paddedX = getNextPOT(textureSurface->w);
int paddedY = getNextPOT(textureSurface->h);
SDL_Rect targetRect;
targetRect.w = oldX;
targetRect.h = oldY;
targetRect.x = (paddedX - oldX) / 2;
targetRect.y = (paddedY - oldY) / 2;
SDL_SetColorKey(textureSurface, SDL_SRCCOLORKEY,
SDL_MapRGB(textureSurface->format, 0, 0, 0));
convertedTexture =
SDL_CreateRGBSurface(SDL_SWSURFACE,
paddedX, paddedY, 32,
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff);
#else
0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
#endif
SDL_BlitSurface(textureSurface, 0, convertedTexture, &targetRect);
if (specular)
{
for (int y = 0; y < convertedTexture->h; ++y)
for (int x = 0; x < convertedTexture->w; ++x)
{
SDL_Color* pixel =
&(((SDL_Color*)convertedTexture->pixels)
[y * convertedTexture->w +x]);
int luminance = int(pixel->r) * 5 - 4 * 256 - 138;
luminance = luminance > 0 ? luminance : 0;
luminance = luminance < 255 ? luminance : 255;
pixel->r = luminance;
pixel->g = luminance;
pixel->b = luminance;
}
}
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
convertedTexture->w, convertedTexture->h, 0, GL_RGBA,
GL_UNSIGNED_BYTE, convertedTexture->pixels);
SDL_FreeSurface(textureSurface);
SDL_FreeSurface(convertedTexture);
return texture;
}
// WARNING:
// This function contains an unusual amount of raw pointers, and is
// the most C-like function you can get without being C++.
// Sorry Joshua.
void Text::render() {
int width = this->width;
int height = this->height;
std::pair<int,int> window_size = window->get_window_size();
// Automatic sizing if dimension is 0.
if (width == 0) {
switch (alignment_h) {
default:
case Alignment::LEFT:
width = window_size.first - this->x;
break;
case Alignment::CENTRE:
width = ((window_size.first / 2) < this->x) ? this->x
: window_size.first - this->x;
break;
case Alignment::RIGHT:
width = this->x;
break;
}
}
if (height == 0) {
switch (alignment_v) {
default:
case Alignment::TOP:
height = this->y;
break;
case Alignment::CENTRE:
height = ((window_size.second / 2) < this->y) ? window_size.second - this->y
: this->y;
break;
case Alignment::BOTTOM:
height = window_size.second - this->y;
break;
}
}
// If they are still zero, don't continue.
if (width == 0 || height == 0) {
throw Text::RenderException("Invalid dimensions after auto-sizing.");
}
int available_width = width;
// It took a whole day to discover that there was a bug in
// SDL_ttf. Starting with certain characters on certain
// fonts seems to break it. :(
// As a hack, prepend and (for balance) append a space.
int border;
TTF_SizeUTF8(font.font, " ", &border, NULL);
border *= 2;
// If they are still zero, don't continue.
if (available_width <= 0) {
throw Text::RenderException("No available width for rendering text.");
}
int line_height = TTF_FontHeight(font.font);
int line_number = 0;
int lost_lines = 0;
int used_width = 0;
int length = (int)text.length();
// Entire text.
const char* ctext = text.c_str();
// Line of text.
char* line = new char[length+1];
// Null-terminator separated lines of text.
// The worst case is a character per line, so we need to do
// 2 * length (character, null, character, null, ...).
char* lines = new char[2*length+1];
// Pointer to within lines.
char* lines_scan = lines;
// Text indexing.
for (int t = 0; t < length; t++) {
int line_width = 0;
// Word indexing.
int w = 0;
// Stores (from the beginning) a word in ctext (copy).
line[0] = '\0';
// Points to the end of the last successfully fitting word in
// line.
int ll = 0;
// Line indexing.
for (int l = t; l < length; l++) {
// Find word end.
for (w = l; w < length && (ctext[w] != ' ' && ctext[w] != '\n'); w++) {
// As we are dealing with UTF-8, we must make sure to
// copy an entire character if it is more than one byte.
// The bit formats of UTF-8 characters are:
// 0xxxxxxx
// 110xxxxx 10xxxxxx
// 1110xxxx 10xxxxxx 10xxxxxx
// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
// 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
// 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
//
// ... Well, actually it's not THAT simple, because
// there are these magical characters which modify other
// characters... But it's not worth the effort.
if (ctext[l] & 0x80) {
// The number of bits in the first byte set to 1
// before the first zero indicate the total number
// of bytes to use for the UTF-8 character.
for (int bits = ctext[w] << 1; w < length && (bits & 0x80); w++, bits <<= 1);
}
}
// Copy word into line.
for (; l < w; l++) {
line[l - t] = ctext[l];
}
line[l - t] = '\0';
// Test line length.
TTF_SizeUTF8(font.font, line, &line_width, NULL);
// Part of SDL_ttf bug workaround.
line_width+=border;
if (line_width <= available_width) {
if (line_width > used_width) {
used_width = line_width;
}
// Mark current position as valid.
ll = l - t;
// If this is the end of a line, or whole text, stop.
if (ctext[w] == '\n' || ctext[w] == '\0') {
t = l;
// Note the string is already null terminated.
break;
}
else {
// Replace null terminator with word separator.
line[ll] = ctext[w];
}
}
else {
if (ll > 0) {
// There are some fittable words.
// As the line overflows with the current l, set the
// text index to the last fit.
t += ll;
}
else {
// There are no separators to break on.
// We're going to have to cut a word in half.
// Swapped-out character
char c;
int left = 0;
int right = l - t;
// Search index within line.
int ls;
ll = 0;
for (ls = (right + left) / 2; ls != ll; ls = (right + left) / 2) {
ll = ls;
c = line[ls];
line[ls] = 0;
TTF_SizeUTF8(font.font, line, &line_width, NULL);
// Part of SDL_ttf bug workaround.
line_width+=border;
if (line_width <= available_width) {
if (line_width > used_width) {
used_width = line_width;
}
left = ls;
}
else {
right = ls;
}
line[ls] = c;
}
// Don't skip the non-separating character.
t += ll - 1;
}
// Null terminate for rendering.
line[ll] = '\0';
break;
}
}
// Copy the line into lines (using lines_scan).
int i;
for (i = 0; line[i] != '\0'; ++i) {
lines_scan[i] = line[i];
}
lines_scan[i] = '\0';
lines_scan = &lines_scan[i+1];
++line_number;
if (line[0] == '\0') {
// Check that we aren't going to chase our tailes trying to fit an unfittable character.
if (ctext[w] != '\n') {
LOG(WARNING) << "Cannot render text: character too large.";
delete[] line;
delete[] lines;
throw Text::RenderException("A character is too large");
}
else {
// It's a blank line.
continue;
}
}
}
int line_count = line_number;
int used_height = line_count * line_height;
used_width += border;
image = Image(used_width, (used_height < height) ? used_height : height, true);
uint8_t clear_colour[4] = {rgba[0], rgba[1], rgba[2], 0x00};
uint8_t clear_mask[4] = {0xff, 0xff, 0xff, 0xff};
image.clear(clear_colour, clear_mask);
// image.clear(0xffffff00, 0xffffffff);
// Render all lines of text.
SDL_Color blank;
blank.r = blank.g = blank.b = blank.a = 0;
SDL_Color colour;
colour.r = rgba[0];
colour.g = rgba[1];
colour.b = rgba[2];
colour.a = rgba[3];
lines_scan = lines;
for (int line_number = 0; line_number < line_count; ++line_number) {
// Render line
VLOG(2) << "Rendering line of text: \"" << lines_scan << "\".";
if (lines_scan[0] == '\0') {
// Skip it - it's a new line.
lines_scan = &lines_scan[1];
continue;
}
SDL_Surface* rendered_line;
{
// It took a whole day to discover that there was a bug in
// SDL_ttf. Starting with certain characters on certain
// fonts seems to break it. :(
// As a hack, prepend and (for balance) append a space.
std::stringstream safe;
safe << " " << lines_scan << " ";
std::string safe_str(safe.str());
if (smooth) {
rendered_line = TTF_RenderUTF8_Shaded(font.font, safe_str.c_str(), colour, blank);
}
else {
rendered_line = TTF_RenderUTF8_Solid(font.font, safe_str.c_str(), colour);
}
}
if (rendered_line == nullptr) {
LOG(WARNING) << "Cannot render line of text: \"" << lines_scan << "\".";
delete[] line;
delete[] lines;
throw Text::RenderException("Cannot render line of text");
}
#ifdef TEXT_SAFE_SURFACE
// This surface has a known format.
SDL_Surface* compatible = SDL_CreateRGBSurface(0, // Unsed
rendered_line->w,
rendered_line->h,
32,
0x00,
0x00,
0x00,
0xff
);
SDL_FillRect(compatible, NULL, 0);
SDL_SetSurfaceBlendMode(rendered_line, SDL_BLENDMODE_NONE);
SDL_BlitSurface(rendered_line, NULL, compatible, NULL);
SDL_LockSurface(compatible);
// pitch is in bytes, not pixels. RGBA = 4 bytes.
int jump = compatible->pitch / 4;
#else
SDL_LockSurface(rendered_line);
int jump = rendered_line->pitch;
#endif
// "What is this pointless copy?" you might ask.
// Well, it is a suggestion to the c++ compiler that smooth
// will not change throughout this function, so it can
// optimise the if containing _smooth out of the for loop
// entirely, rather than checking it every single iteration.
int _smooth = smooth;
int x_offset;
int y_offset;
switch (alignment_h) {
default:
case Alignment::LEFT:
x_offset = 0;
break;
case Alignment::CENTRE:
x_offset = (used_width - rendered_line->w) / 2;
break;
case Alignment::RIGHT:
x_offset = used_width - rendered_line->w;
break;
}
switch (alignment_v) {
default:
case Alignment::TOP:
y_offset = line_number * line_height;
break;
case Alignment::CENTRE:
y_offset = line_number * line_height - (used_height - image.height) / 2;
break;
case Alignment::BOTTOM:
y_offset = line_number * line_height - (used_height - image.height);
break;
}
// x surface
int xs;
// y surface
int ys;
for (ys = 0; ys < rendered_line->h; ++ys) {
int yi = ys + y_offset;
if (yi >= image.height) {
lost_lines++;
break;
}
else if (yi < 0) {
continue;
}
int begin_xs((x_offset >= 0) ? 0 : -x_offset);
int end_xs((rendered_line->w < image.width - x_offset) ? rendered_line->w : image.width - x_offset);
for (xs = begin_xs; xs < end_xs; ++xs) {
#ifdef TEXT_SAFE_SURFACE
image.flipped_pixels[yi][xs + x_offset].a = (((Uint32*)compatible->pixels)[(ys*jump + xs)]);
#else
if (_smooth) {
image.flipped_pixels[yi][xs + x_offset].a = (((Uint8*)rendered_line->pixels)[(ys*jump + xs)]);
}
else {
image.flipped_pixels[yi][xs + x_offset].a = (((Uint8*)rendered_line->pixels)[(ys*jump + xs)]) ? 255 : 0;
}
#endif
}
}
#ifdef TEXT_SAFE_SURFACE
SDL_UnlockSurface(compatible);
SDL_FreeSurface(compatible);
#else
SDL_UnlockSurface(rendered_line);
#endif
SDL_FreeSurface(rendered_line);
if (ys < line_height) {
LOG(WARNING) << "Text overflow.";
break;
}
// Set lines_scan to start next line
while (lines_scan[0] != '\0') {
lines_scan = &lines_scan[1];
}
lines_scan = &lines_scan[1];
}
this->used_width = used_width;
this->used_height = used_height;
delete[] line;
delete[] lines;
generate_texture();
dirty_texture = false;
dirty_vbo = true;
}
int main(int argc, char *argv[])
{
Uint32 initflags = SDL_INIT_VIDEO; //| SDL_DOUBLEBUF; /* See documentation for details */
SDL_Surface *ecran, *rectangle, *board, *texte1; // quelques surfaces
Dimensions fenetre; // main window
fenetre.h = WINHI; // en pixels
fenetre.w = WINWI;
Uint8 video_bpp = 32; // 32 bits de couleur
Uint32 videoflags = SDL_HWSURFACE; // utiliser la mémoire vidéo
Uint32 vert, rouge; // des variables pour des couleurs
bool continuer; // pour la boucle principale des évènements
SDL_Event event; // aussi
/* Initialize the SDL library */
if ( SDL_Init(initflags) < 0 )
{
fprintf(stderr, "N'arrive pas a` initialiser la SDL : %s\n", SDL_GetError());
exit(1);
}
/* Set video mode */
ecran = SDL_SetVideoMode(fenetre.w, fenetre.h, video_bpp, videoflags); // surface principale
if (ecran == NULL)
{
fprintf(stderr, "N'arrive pas a` etablir mode video%dx%dx%d : %s\n", fenetre.w, fenetre.h, video_bpp, SDL_GetError());
SDL_Quit();
exit(2);
}
vert = SDL_MapRGB(ecran->format,0,128,0); // c'est du vert
rouge = SDL_MapRGB(ecran->format,255,0,0); // c'est du rouge
SDL_FillRect(ecran,NULL,vert); // de la couleur dans le fond de la fenêtre principale
SDL_WM_SetCaption("Jeu de Hex", NULL); // legende de la fenêtre
// Une autre surface avec du texte
TTF_Init();
TTF_Font *fontMenu = TTF_OpenFont("CAC-Champagne/cac_champagne.ttf",60); // charger une fonte (un peu moche)
SDL_Color fontBlack = {0,0,0};
texte1 = TTF_RenderText_Blended(fontMenu,"Projet Hex !",fontBlack);
// encore une surface
rectangle = SDL_CreateRGBSurface(initflags,225,80,video_bpp,0,0,0,0); // une autre surface pour inclure dans l'autre
SDL_FillRect(rectangle,NULL,rouge); // un fond rouge
// position des surfaces
SDL_Rect posRect, posTexte1;
posRect.x = 20;
posRect.y = 80;
posTexte1.x = 25;
posTexte1.y = 85;
SDL_BlitSurface(rectangle,NULL,ecran,&posRect); // on associe avec la fenêtre principale
SDL_BlitSurface(texte1,NULL,ecran,&posTexte1); // idem pour superposer avec la précédente
// Affichage du plateau de jeu
board = IMG_Load("Images/hex.png"); // plateau de jeu la taille en pixels est celle de l'image
SDL_Rect posBoard; // sa position
posBoard.x = 280;
posBoard.y = 100;
SDL_BlitSurface(board,NULL,ecran,&posBoard); // on l'associe avec la surface principale
// affichage du pion bleu
SDL_Surface *pionBleu;
pionBleu = IMG_Load("Images/button-blue22.png");
SDL_Rect posPionBleu;
posPionBleu.x = 385;
posPionBleu.y = 149;
SDL_BlitSurface(pionBleu,NULL,ecran,&posPionBleu);
// Affichege du pion rouge
SDL_Surface *pionRouge = IMG_Load("Images/button-red22.png");
SDL_Rect posPionRouge;
posPionRouge.x = 543;
posPionRouge.y = 273;
SDL_BlitSurface(pionRouge,NULL,ecran,&posPionRouge);
SDL_Flip(ecran); //maj des surfaces
// boucle des évènements
continuer = true; // un furieux du c ferait plutôt une boucle infinie. Je préfère rester correct.
SDLKey key_pressed ;
while (continuer)
{
while ( SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_MOUSEMOTION:
printf("Ça bouge\n"); // sans intérêt, c'est juste pour montrer
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT)
{
int clicX = event.motion.x;
int clicY = event.motion.y;
printf("X=%d Y=%d\n",clicX,clicY); // on récupère les coordonnées du clic
}
break;
case SDL_KEYDOWN:
key_pressed = event.key.keysym.sym; // on récupère la touche
switch (key_pressed)
{
case SDLK_ESCAPE: /* Esc keypress quits the app... */
continuer = false;
break;
case SDLK_LEFT:
printf("left +1\n"); // par exemple
break;
case SDLK_RIGHT:
printf("right +1\n");
break;
case SDLK_UP:
printf("up +1\n");
break;
case SDLK_DOWN:
printf("down +1\n");
break;
}
break;
case SDL_QUIT:
continuer = false;
break;
default:
break;
}
}
// refresh screen
// mettre ici tous les blit utiles s'il y a des changements dans les surfaces, board, nouveaux pions
SDL_Flip(ecran); //maj des surfaces pour affichage
}
//
/* Clean up the SDL library */
SDL_FreeSurface(ecran);
SDL_FreeSurface(rectangle);
SDL_FreeSurface(board);
TTF_CloseFont(fontMenu);
SDL_FreeSurface(texte1);
TTF_Quit();
SDL_Quit();
return(0);
}
SDL_Surface *DIB_SetVideoMode(_THIS, SDL_Surface *current,
int width, int height, int bpp, Uint32 flags)
{
SDL_Surface *video;
Uint32 prev_flags;
DWORD style;
const DWORD directstyle =
(WS_POPUP);
const DWORD windowstyle =
(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX);
const DWORD resizestyle =
(WS_THICKFRAME|WS_MAXIMIZEBOX);
int binfo_size;
BITMAPINFO *binfo;
HDC hdc;
RECT bounds;
int x, y;
Uint32 Rmask, Gmask, Bmask;
#ifdef HAVE_OPENGL //maks
/* Clean up any GL context that may be hanging around */
if ( current->flags & SDL_OPENGL ) { //maks: close only in viewo quit to avoid texture lost when go to game mode
WIN_GL_ShutDown(this);
}
#endif
/* Recalculate the bitmasks if necessary */
if ( bpp == current->format->BitsPerPixel ) {
video = current;
} else {
switch (bpp) {
case 15:
case 16:
if ( DIB_SussScreenDepth() == 15 ) {
/* 5-5-5 */
Rmask = 0x00007c00;
Gmask = 0x000003e0;
Bmask = 0x0000001f;
} else {
/* 5-6-5 */
Rmask = 0x0000f800;
Gmask = 0x000007e0;
Bmask = 0x0000001f;
}
break;
case 24:
case 32:
/* GDI defined as 8-8-8 */
Rmask = 0x00ff0000;
Gmask = 0x0000ff00;
Bmask = 0x000000ff;
break;
default:
Rmask = 0x00000000;
Gmask = 0x00000000;
Bmask = 0x00000000;
break;
}
video = SDL_CreateRGBSurface(SDL_SWSURFACE,
0, 0, bpp, Rmask, Gmask, Bmask, 0);
if ( video == NULL ) {
SDL_OutOfMemory();
return(NULL);
}
}
/* Fill in part of the video surface */
prev_flags = video->flags;
video->flags = 0; /* Clear flags */
video->w = width;
video->h = height;
video->pitch = SDL_CalculatePitch(video);
#ifdef WIN32_PLATFORM_PSPC
/* Stuff to hide that $#!^%#$ WinCE taskbar in fullscreen... */
if ( flags & SDL_FULLSCREEN ) {
if ( !(prev_flags & SDL_FULLSCREEN) ) {
SHFullScreen(SDL_Window, SHFS_HIDETASKBAR);
SHFullScreen(SDL_Window, SHFS_HIDESIPBUTTON);
ShowWindow(FindWindow(TEXT("HHTaskBar"),NULL),SW_HIDE);
}
video->flags |= SDL_FULLSCREEN;
} else {
if ( prev_flags & SDL_FULLSCREEN ) {
SHFullScreen(SDL_Window, SHFS_SHOWTASKBAR);
SHFullScreen(SDL_Window, SHFS_SHOWSIPBUTTON);
ShowWindow(FindWindow(TEXT("HHTaskBar"),NULL),SW_SHOWNORMAL);
}
}
#endif
#ifndef NO_CHANGEDISPLAYSETTINGS
/* Set fullscreen mode if appropriate */
if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
DEVMODE settings;
memset(&settings, 0, sizeof(DEVMODE));
settings.dmSize = sizeof(DEVMODE);
settings.dmBitsPerPel = video->format->BitsPerPixel;
settings.dmPelsWidth = width;
settings.dmPelsHeight = height;
settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
if ( ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL ) {
video->flags |= SDL_FULLSCREEN;
SDL_fullscreen_mode = settings;
}
}
#endif /* !NO_CHANGEDISPLAYSETTINGS */
/* Reset the palette and create a new one if necessary */
if ( screen_pal != NULL ) {
/* RJR: March 28, 2000
delete identity palette if switching from a palettized mode */
DeleteObject(screen_pal);
screen_pal = NULL;
}
if ( bpp <= 8 )
{
/* RJR: March 28, 2000
create identity palette switching to a palettized mode */
screen_pal = DIB_CreatePalette(bpp);
}
style = GetWindowLong(SDL_Window, GWL_STYLE);
style &= ~(resizestyle|WS_MAXIMIZE);
if ( (video->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
style &= ~windowstyle;
style |= directstyle;
} else {
#ifndef NO_CHANGEDISPLAYSETTINGS
if ( (prev_flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
ChangeDisplaySettings(NULL, 0);
}
#endif
if ( flags & SDL_NOFRAME ) {
style &= ~windowstyle;
style |= directstyle;
video->flags |= SDL_NOFRAME;
} else {
style &= ~directstyle;
style |= windowstyle;
if ( flags & SDL_RESIZABLE ) {
style |= resizestyle;
video->flags |= SDL_RESIZABLE;
}
}
#if WS_MAXIMIZE
if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE;
#endif
}
/* DJM: Don't piss of anyone who has setup his own window */
if ( SDL_windowid == NULL )
SetWindowLong(SDL_Window, GWL_STYLE, style);
/* Delete the old bitmap if necessary */
if ( screen_bmp != NULL ) {
DeleteObject(screen_bmp);
}
if ( ! (flags & SDL_OPENGL) ) {
BOOL is16bitmode = (video->format->BytesPerPixel == 2);
/* Suss out the bitmap info header */
binfo_size = sizeof(*binfo);
if( is16bitmode ) {
/* 16bit modes, palette area used for rgb bitmasks */
binfo_size += 3*sizeof(DWORD);
} else if ( video->format->palette ) {
binfo_size += video->format->palette->ncolors *
sizeof(RGBQUAD);
}
binfo = (BITMAPINFO *)malloc(binfo_size);
if ( ! binfo ) {
if ( video != current ) {
SDL_FreeSurface(video);
}
SDL_OutOfMemory();
return(NULL);
}
binfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
binfo->bmiHeader.biWidth = video->w;
binfo->bmiHeader.biHeight = -video->h; /* -ve for topdown bitmap */
binfo->bmiHeader.biPlanes = 1;
binfo->bmiHeader.biSizeImage = video->h * video->pitch;
binfo->bmiHeader.biXPelsPerMeter = 0;
binfo->bmiHeader.biYPelsPerMeter = 0;
binfo->bmiHeader.biClrUsed = 0;
binfo->bmiHeader.biClrImportant = 0;
binfo->bmiHeader.biBitCount = video->format->BitsPerPixel;
if ( is16bitmode ) {
/* BI_BITFIELDS tells CreateDIBSection about the rgb masks in the palette */
binfo->bmiHeader.biCompression = BI_BITFIELDS;
((Uint32*)binfo->bmiColors)[0] = video->format->Rmask;
((Uint32*)binfo->bmiColors)[1] = video->format->Gmask;
((Uint32*)binfo->bmiColors)[2] = video->format->Bmask;
} else {
binfo->bmiHeader.biCompression = BI_RGB; /* BI_BITFIELDS for 565 vs 555 */
if ( video->format->palette ) {
memset(binfo->bmiColors, 0,
video->format->palette->ncolors*sizeof(RGBQUAD));
}
}
/* Create the offscreen bitmap buffer */
hdc = GetDC(SDL_Window);
screen_bmp = CreateDIBSection(hdc, binfo, DIB_RGB_COLORS,
(void **)(&video->pixels), NULL, 0);
ReleaseDC(SDL_Window, hdc);
free(binfo);
if ( screen_bmp == NULL ) {
if ( video != current ) {
SDL_FreeSurface(video);
}
SDL_SetError("Couldn't create DIB section");
return(NULL);
}
this->UpdateRects = DIB_NormalUpdate;
/* Set video surface flags */
if ( bpp <= 8 ) {
/* BitBlt() maps colors for us */
video->flags |= SDL_HWPALETTE;
}
}
/* Resize the window */
if ( SDL_windowid == NULL ) {
HWND top;
UINT swp_flags;
const char *window = getenv("SDL_VIDEO_WINDOW_POS");
const char *center = getenv("SDL_VIDEO_CENTERED");
if ( !SDL_windowX && !SDL_windowY ) {
if ( window ) {
if ( sscanf(window, "%d,%d", &x, &y) == 2 ) {
SDL_windowX = x;
SDL_windowY = y;
}
if ( strcmp(window, "center") == 0 ) {
center = window;
window = NULL;
}
}
}
swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW);
SDL_resizing = 1;
bounds.left = SDL_windowX;
bounds.top = SDL_windowY;
bounds.right = SDL_windowX+video->w;
bounds.bottom = SDL_windowY+video->h;
AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), FALSE, 0);
width = bounds.right-bounds.left;
height = bounds.bottom-bounds.top;
if ( (flags & SDL_FULLSCREEN) ) {
x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
} else if ( SDL_windowX || SDL_windowY || window ) {
x = bounds.left;
y = bounds.top;
} else if ( center ) {
x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
} else {
x = y = -1;
swp_flags |= SWP_NOMOVE;
}
if ( y < 0 ) { /* Cover up title bar for more client area */
y -= GetSystemMetrics(SM_CYCAPTION)/2;
}
if ( flags & SDL_FULLSCREEN ) {
top = HWND_TOPMOST;
} else {
top = HWND_NOTOPMOST;
}
SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags);
SDL_resizing = 0;
SetForegroundWindow(SDL_Window);
}
#ifdef HAVE_OPENGL //maks
/* Set up for OpenGL */
if ( flags & SDL_OPENGL )
{
/*if ( WIN_GL_SetupWindow(this) < 0 ) {
return(NULL);
}
video->flags |= SDL_OPENGL;*/
if ( WIN_GL_SetupWindow(this) >= 0 )
{
video->flags |= SDL_OPENGL;
}
}
#endif
/* We're live! */
return(video);
}
//Private
sFont cFontManager::GenerateFont(TTF_Font *font, int size){
sFont tFont;
int tmpWidth = size;
int tmpHeight = TTF_FontHeight(font);
tFont.newLine = tmpHeight;
Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
int xMax = 0, yMax = 0;
SDL_Surface *tmpSurface = SDL_CreateRGBSurface(0,
1024, 1024, 32, rmask, gmask, bmask, amask);
xMax = 1024 / tmpWidth;
yMax = 1024 / tmpHeight;
SDL_FillRect(tmpSurface, NULL, SDL_MapRGBA(tmpSurface->format, 255, 255, 255, 0));
SDL_Rect tmpRect = {0, 0, tmpWidth, tmpHeight};
SDL_Color color = {255, 255, 255};
std::vector<std::string> horLines; //[0] Holds all character on first horizontal line
std::vector<std::vector<sRect> > horLinesRect;//Holds position and size for each character
bool isDone = false;
uint tmpP = 0; //Temp pointer for chars array
for(int i = 0; i < yMax && !isDone; i++){
tmpRect.y = (int)(i * tmpHeight);
std::string tmpLine = "";
std::vector<sRect> tmpRectVec;
for(int j = 0; j < xMax; j++){
tmpRect.x = (int)(j * tmpWidth);
if(tmpP < chars.size() - 1){
SDL_Surface *tmpSur;
int minX = 0, maxX = 0, minY = 0, maxY = 0;;
sRect tRect;
tRect.x = tmpRect.x;
tRect.y = tmpRect.y;
tRect.w = 0;
tRect.h = tmpRect.h;
if(IsUtf8(chars, tmpP)){
std::string ts = chars.substr(tmpP, 2);
tmpSur = TTF_RenderUTF8_Solid(font, (char*)ts.c_str(), color);
Uint16 ch = ts.c_str()[0] + ts.c_str()[1];
ch =(ch<<8) | ts.c_str()[1]; //This may not work
ch =(ch<<8) | ts.c_str()[0];
TTF_GlyphMetrics(font, ch, &minX, &maxX, &minY, &maxY, NULL);
tmpP += 2;
tmpLine += ts;
}else{
char tmpC[2];
tmpC[0] = chars.at(tmpP);
tmpC[1] = '\0';
tmpSur = TTF_RenderUTF8_Solid(font, (char*)tmpC, color);
TTF_GlyphMetrics(font, tmpC[0], &minX, &maxX, &minY, &maxY, NULL);
if(tmpC[0] == 'j' || tmpC[0] == 'J'){
maxX += 2;
}
tmpLine += chars.at(tmpP);
tmpP += 1;
}
//tRect.y += maxY;
tRect.x += minX;
tRect.w = maxX - minX;
tmpRectVec.push_back(tRect);
SDL_BlitSurface(tmpSur, NULL, tmpSurface, &tmpRect);
SDL_FreeSurface(tmpSur);
}else{
isDone = true;
break;
}
}
horLines.push_back(tmpLine);
horLinesRect.push_back(tmpRectVec);
tmpRectVec.clear();
}
tFont.spacing = DEF_SPACING;
tFont.size = size;
tFont.texture = tManager->LoadTextureFromMemory(tmpSurface);
for(int i = 0; i < (int)horLinesRect.size(); i++){
tmpP = 0;
for(int j = 0; j < (int)horLinesRect[i].size(); j++){
sRect *tmpR = &horLinesRect[i][j];
uint tmpS = tManager->CreateSection(tFont.texture,
tmpR->x, tmpR->y,
tmpR->w, tmpR->h);
if(IsUtf8(horLines[i], tmpP)){
std::string tmpG = horLines[i].substr(tmpP, 2);
tFont.glyphs[tmpG] = tmpS;
tmpP += 2;
}else{
char tmpchar[2];
tmpchar[0] = horLines[i].at(tmpP);
tmpchar[1] = '\0';
tFont.glyphs[(char*)tmpchar] = tmpS;
tmpP += 1;
}
}
}
//SDL_SaveBMP(tmpSurface, "temp_font.bmp");
SDL_FreeSurface(tmpSurface);
return tFont;
}
//--------------------------------------------------
int Texture::loadFile(string pName)
{
ErrorLog *log = ErrorLog::getInstance();
stringstream logStream;
logStream << "Load Texture " << pName.c_str() << endl;
log->reportError(logStream.str());
string name;
name = "./Daten/Textures/";
name.append(pName);
name.append(".bmp");
SDL_Surface *bitmap; // SDL_Surface to load the image into
SDL_Surface *conv; // SDL_Surface to copy the image into (with correct color order)
int pitch; // Variable to store the length of one pixel-line
int height_div_2; // Variable to store the size of half the number of rows
void* temp_row; // Variable to store the pointer to a pixel-line
bitmap = SDL_LoadBMP(name.c_str()); // Load image into an SDL_Surface
if (!bitmap) // If loading failed
{ //
// print an error message
logStream.str("");
logStream << "Could not load BMP texture: " << name.c_str() << endl;
log->reportError(logStream.str());
return -1; // and quit
}
#if SDL_BYTEORDER == SDL_BIG_ENDIAN // Select wether we use RGB or BGR mode
conv = SDL_CreateRGBSurface(SDL_SWSURFACE, bitmap->w, bitmap->h, 32, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff); // Create an SDL-Surface (big endian)
#else
conv = SDL_CreateRGBSurface(SDL_SWSURFACE, bitmap->w, bitmap->h, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000); // Create an SDL-Surface (little endian)
#endif
SDL_BlitSurface(bitmap, 0, conv, 0); // Copy the loaded image to the surface with the correct color order
// Flip Loaded Bitmap upside down
// (SDL and OpenGL use diffrent Coordinate Systems)
////////////////////////////////////////////////////////
pitch = conv->pitch; // length of one pixel-line
temp_row = (void *)malloc(pitch); // Allocate memory for the inversion
if (NULL == temp_row) // If you're not able to allocate the memory
{ //
//SDL_SetError("Not enough memory for image inversion"); // display an error message
logStream.str("");
logStream << "Not enough memory for image inversion" << endl;
log->reportError(logStream.str());
}
height_div_2 = (int) (conv->h * .5); // use only one half of the rows. (Works also with a odd number of rows)
for (int index = 0; index < height_div_2; index++) // for every line in the lower half swap it with the corresponding line
{ // in the upper half
memcpy(
(Uint8 *)temp_row, //
(Uint8 *)(conv->pixels) + pitch * index, // copy one line from the first half to the temp variable
pitch); // size of one line
memcpy(
(Uint8 *)(conv->pixels) + pitch * index, //
(Uint8 *)(conv->pixels) + pitch * (conv->h - index - 1), // copy the corresponding line from the upper half to the line in the lower half
pitch); // size of one line
memcpy(
(Uint8 *)(conv->pixels) + pitch * (conv->h - index - 1), //
temp_row, // copy the tempvariable back to the corresponding line in the upper half
pitch); // size of one line
}
free(temp_row); // free allocated memory now that we don't need it anymore
//use purple as transparent
/*for (int i = 0;i < conv->w;i++)
{
for (int j = 0;j < conv->h;j++)
{
unsigned int color;
color = ((unsigned int*)conv->pixels)[j*(conv->pitch/sizeof(unsigned int)) + i];
color = color & 0x00ffffff;
if (color == 16711935)
{
((unsigned int*)conv->pixels)[j*(conv->pitch/sizeof(unsigned int)) + i] = 0x00ffffff;
}
}
}*/
unsigned int texture;
glGenTextures(1, &texture);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, conv->w, conv->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, conv->pixels); //copy the image into the texture
SDL_FreeSurface(bitmap);
SDL_FreeSurface(conv);
return texture;
}
VOID
PAL_EndingAnimation(
VOID
)
/*++
Purpose:
Show the ending animation.
Parameters:
None.
Return value:
None.
--*/
{
LPBYTE buf;
LPBYTE bufGirl;
SDL_Surface *pUpper;
SDL_Surface *pLower;
SDL_Rect srcrect, dstrect;
int yPosGirl = 180;
int i;
buf = (LPBYTE)UTIL_calloc(1, 64000);
bufGirl = (LPBYTE)UTIL_calloc(1, 6000);
pUpper = SDL_CreateRGBSurface(gpScreen->flags & ~SDL_HWSURFACE, 320, 200, 8,
gpScreen->format->Rmask, gpScreen->format->Gmask,
gpScreen->format->Bmask, gpScreen->format->Amask);
pLower = SDL_CreateRGBSurface(gpScreen->flags & ~SDL_HWSURFACE, 320, 200, 8,
gpScreen->format->Rmask, gpScreen->format->Gmask,
gpScreen->format->Bmask, gpScreen->format->Amask);
PAL_MKFDecompressChunk(buf, 64000, 61, gpGlobals->f.fpFBP);
PAL_FBPBlitToSurface(buf, pUpper);
PAL_MKFDecompressChunk(buf, 64000, 62, gpGlobals->f.fpFBP);
PAL_FBPBlitToSurface(buf, pLower);
PAL_MKFDecompressChunk(buf, 64000, 571, gpGlobals->f.fpMGO);
PAL_MKFDecompressChunk(bufGirl, 6000, 572, gpGlobals->f.fpMGO);
srcrect.x = 0;
dstrect.x = 0;
srcrect.w = 320;
dstrect.w = 320;
gpGlobals->wScreenWave = 2;
for (i = 0; i < 400; i++)
{
//
// Draw the background
//
srcrect.y = 0;
srcrect.h = 200 - i / 2;
dstrect.y = i / 2;
dstrect.h = 200 - i / 2;
SDL_BlitSurface(pLower, &srcrect, gpScreen, &dstrect);
srcrect.y = 200 - i / 2;
srcrect.h = i / 2;
dstrect.y = 0;
dstrect.h = i / 2;
SDL_BlitSurface(pUpper, &srcrect, gpScreen, &dstrect);
PAL_ApplyWave(gpScreen);
//
// Draw the beast
//
PAL_RLEBlitToSurface(PAL_SpriteGetFrame(buf, 0), gpScreen, PAL_XY(0, -400 + i));
PAL_RLEBlitToSurface(PAL_SpriteGetFrame(buf, 1), gpScreen, PAL_XY(0, -200 + i));
//
// Draw the girl
//
yPosGirl -= i & 1;
if (yPosGirl < 80)
{
yPosGirl = 80;
}
PAL_RLEBlitToSurface(PAL_SpriteGetFrame(bufGirl, (SDL_GetTicks() / 50) % 4),
gpScreen, PAL_XY(220, yPosGirl));
//
// Update the screen
//
VIDEO_UpdateScreen(NULL);
if (gpGlobals->fNeedToFadeIn)
{
PAL_FadeIn(gpGlobals->wNumPalette, gpGlobals->fNightPalette, 1);
gpGlobals->fNeedToFadeIn = FALSE;
}
UTIL_Delay(50);
}
gpGlobals->wScreenWave = 0;
SDL_FreeSurface(pUpper);
SDL_FreeSurface(pLower);
free(buf);
free(bufGirl);
}
static void ANDROID_UnlockHWSurface(_THIS, SDL_Surface *surface)
{
SDL_PixelFormat format;
Uint32 hwformat = SDL_PIXELFORMAT_RGBA5551;
int bpp;
SDL_Surface * converted = NULL;
if( !SDL_ANDROID_InsideVideoThread() )
{
__android_log_print(ANDROID_LOG_INFO, "libSDL", "Error: calling %s not from the main thread!", __PRETTY_FUNCTION__);
return;
}
if( !surface->hwdata )
return;
if( surface->format->Amask )
hwformat = SDL_PIXELFORMAT_RGBA4444;
if( surface == SDL_CurrentVideoSurface ) // Special case
hwformat = SDL_PIXELFORMAT_RGB565;
/* Allocate the new pixel format for the screen */
SDL_memset(&format, 0, sizeof(format));
SDL_PixelFormatEnumToMasks( hwformat, &bpp,
&format.Rmask, &format.Gmask,
&format.Bmask, &format.Amask );
format.BytesPerPixel = ANDROID_BYTESPERPIXEL;
format.BitsPerPixel = bpp;
if( format.BitsPerPixel == surface->format->BitsPerPixel &&
format.Rmask == surface->format->Rmask &&
format.Gmask == surface->format->Gmask &&
format.Bmask == surface->format->Bmask &&
format.Amask == surface->format->Amask )
{
DEBUGOUT("ANDROID_UnlockHWSurface() no conversion");
converted = surface; // No need for conversion
}
else
{
Uint16 x, y;
converted = SDL_CreateRGBSurface(SDL_SWSURFACE, surface->w, surface->h, format.BitsPerPixel,
format.Rmask, format.Gmask, format.Bmask, format.Amask);
if( !converted ) {
SDL_OutOfMemory();
return;
}
#define CONVERT_RGB565_RGBA5551( pixel ) (0x1 | ( (pixel & 0xFFC0) | ( (pixel & 0x1F) << 1 ) ))
if( surface->flags & SDL_SRCCOLORKEY )
{
DEBUGOUT("ANDROID_UnlockHWSurface() CONVERT_RGB565_RGBA5551 + colorkey");
for( y = 0; y < surface->h; y++ )
{
Uint16* src = (Uint16 *)( surface->pixels + surface->pitch * y );
Uint16* dst = (Uint16 *)( converted->pixels + converted->pitch * y );
Uint16 w = surface->w;
Uint16 key = surface->format->colorkey;
Uint16 pixel;
for( x = 0; x < w; x++, src++, dst++ )
{
pixel = *src;
*dst = (pixel == key) ? 0 : CONVERT_RGB565_RGBA5551( pixel );
}
}
}
else
{
DEBUGOUT("ANDROID_UnlockHWSurface() CONVERT_RGB565_RGBA5551");
for( y = 0; y < surface->h; y++ )
{
Uint16* src = (Uint16 *)( surface->pixels + surface->pitch * y );
Uint16* dst = (Uint16 *)( converted->pixels + converted->pitch * y );
Uint16 w = surface->w;
Uint16 pixel;
for( x = 0; x < w; x++, src++, dst++ )
{
pixel = *src;
*dst = CONVERT_RGB565_RGBA5551( pixel );
}
}
}
}
SDL_Rect rect;
rect.x = 0;
rect.y = 0;
rect.w = surface->w;
rect.h = surface->h;
SDL_UpdateTexture((struct SDL_Texture *)surface->hwdata, &rect, converted->pixels, converted->pitch);
if( surface == SDL_CurrentVideoSurface ) // Special case
SDL_RenderCopy((struct SDL_Texture *)SDL_CurrentVideoSurface->hwdata, NULL, NULL);
if( converted != surface )
SDL_FreeSurface(converted);
}
bool CApp::OnInit() {
if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
return false;
}
if (IMG_Init(IMG_INIT_PNG) == 0) {
return false;
}
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_WARN);
SDL_LogGetOutputFunction(&logfunc, NULL);
SDL_LogSetOutputFunction(myLog, NULL);
SDL_CreateWindowAndRenderer(SCREEN_W, SCREEN_H, 0, &Window, &Renderer);
if (!Window || !Renderer) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "CreateWindowAndRenderer: %s", SDL_GetError());
return false;
}
SDL_SetWindowTitle(Window, TITLE);
Surf_Display = SDL_CreateRGBSurface(0, SCREEN_W, SCREEN_H, BPP,
RMASK, GMASK, BMASK, AMASK);
if (!Surf_Display) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "CreateRGBSurface: %s", SDL_GetError());
return false;
}
SDL_FillRect(Surf_Display, NULL, 0);
Texture = SDL_CreateTexture(Renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, SCREEN_W, SCREEN_H);
if (!Texture) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "CreateTexture: %s", SDL_GetError());
return false;
}
CEventFilter::SetDefaults(); // or use your own filters
CEventFilter::TurnFilterOn(&InputHappened);
// PROGRAM SPECIFIC CODE HERE
bg = SDL_CreateRGBSurface(0, SCREEN_W, SCREEN_H, BPP, RMASK, GMASK, BMASK, AMASK);
if (!bg) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "CSurface::OnLoad: %s", SDL_GetError());
return false;
}
SDL_FillRect(bg, NULL, 0xfff0f0f0);
VerticalSpriteSheet* dude = new VerticalSpriteSheet("gfx/char.png", 1, Surf_Display->format);
ActionJackson.SetSpriteSheet(dude);
ActionJackson.AnimState = 0;
CEntity::EntityList.push_back(&ActionJackson);
SDL_SetWindowIcon(Window, dude->sheet);
tiles = new TiledSpriteSheet("gfx/tiles.png", 2, 2, Surf_Display->format);
block = new VerticalSpriteSheet("gfx/block.png", 1, Surf_Display->format);
if (!LoadMaps("maps/sokoban.map", tiles))
return false;
std::ifstream fin("save");
if (fin) {
fin >> CurrentMap;
fin.ignore(1, '\n');
fin >> highestLevel;
}
fin.close();
ResetMap(CurrentMap);
return true;
}
/* read XPM from either array or RWops */
static SDL_Surface *load_xpm(const char **xpm, SDL_RWops *src)
{
SDL_Surface *image = NULL;
int indexc;
int x, y;
int w, h, ncolors, cpp;
int indexed;
Uint8 *dst;
struct color_hash *colors = NULL;
SDL_Color *im_colors = NULL;
char *keystrings = NULL, *nextkey;
const char *line;
const char ***xpmlines = NULL;
int pixels_len;
error = NULL;
linebuf = NULL;
buflen = 0;
if (xpm)
xpmlines = &xpm;
line = get_next_line(xpmlines, src, 0);
if (!line)
goto done;
/*
* The header string of an XPMv3 image has the format
*
* <width> <height> <ncolors> <cpp> [ <hotspot_x> <hotspot_y> ]
*
* where the hotspot coords are intended for mouse cursors.
* Right now we don't use the hotspots but it should be handled
* one day.
*/
if (sscanf(line, "%d %d %d %d", &w, &h, &ncolors, &cpp) != 4
|| w <= 0 || h <= 0 || ncolors <= 0 || cpp <= 0) {
error = "Invalid format description";
goto done;
}
keystrings = malloc(ncolors * cpp);
if (!keystrings) {
error = "Out of memory";
goto done;
}
nextkey = keystrings;
/* Create the new surface */
if (ncolors <= 256) {
indexed = 1;
image = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 8,
0, 0, 0, 0);
im_colors = image->format->palette->colors;
image->format->palette->ncolors = ncolors;
} else {
indexed = 0;
image = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32,
0xff0000, 0x00ff00, 0x0000ff, 0);
}
if (!image) {
/* Hmm, some SDL error (out of memory?) */
goto done;
}
/* Read the colors */
colors = create_colorhash(ncolors);
if (!colors) {
error = "Out of memory";
goto done;
}
for (indexc = 0; indexc < ncolors; ++indexc ) {
const char *p;
line = get_next_line(xpmlines, src, 0);
if (!line)
goto done;
p = line + cpp + 1;
/* parse a colour definition */
for (;;) {
char nametype;
const char *colname;
Uint32 rgb, pixel;
SKIPSPACE(p);
if (!*p) {
error = "colour parse error";
goto done;
}
nametype = *p;
SKIPNONSPACE(p);
SKIPSPACE(p);
colname = p;
SKIPNONSPACE(p);
if (nametype == 's')
continue; /* skip symbolic colour names */
if (!color_to_rgb(colname, p - colname, &rgb))
continue;
memcpy(nextkey, line, cpp);
if (indexed) {
SDL_Color *c = im_colors + indexc;
c->r = (Uint8)(rgb >> 16);
c->g = (Uint8)(rgb >> 8);
c->b = (Uint8)(rgb);
pixel = indexc;
} else
pixel = rgb;
add_colorhash(colors, nextkey, cpp, pixel);
nextkey += cpp;
if (rgb == 0xffffffff)
SDL_SetColorKey(image, SDL_SRCCOLORKEY, pixel);
break;
}
}
int Engine::createBackground() {
background = SDL_CreateRGBSurface(0, win_width, win_height, 32, 0, 0, 0, 0);
return 0;
}
void TextureBuilder::PrepareSurface()
{
if (m_prepared) return;
if (!m_surface && !m_filename.empty()) {
std::string filename = m_filename;
std::transform(filename.begin(), filename.end(), filename.begin(), ::tolower);
if (ends_with_ci(filename, ".dds")) {
LoadDDS();
} else {
LoadSurface();
}
}
TextureFormat targetTextureFormat;
unsigned int virtualWidth, actualWidth, virtualHeight, actualHeight, numberOfMipMaps = 0, numberOfImages = 1;
if( m_surface ) {
SDL_PixelFormat *targetPixelFormat;
bool needConvert = !GetTargetFormat(m_surface->format, &targetTextureFormat, &targetPixelFormat, m_forceRGBA);
if (needConvert) {
if(m_textureType == TEXTURE_2D) {
SDL_Surface *s = SDL_ConvertSurface(m_surface.Get(), targetPixelFormat, SDL_SWSURFACE);
m_surface = SDLSurfacePtr::WrapNew(s);
} else if(m_textureType == TEXTURE_CUBE_MAP) {
assert(m_cubemap.size() == 6);
for(unsigned int i = 0; i < 6; ++i) {
SDL_Surface *s = SDL_ConvertSurface(m_cubemap[i].Get(), targetPixelFormat, SDL_SWSURFACE);
m_cubemap[i] = SDLSurfacePtr::WrapNew(s);
}
} else {
// Unknown texture type
assert(0);
}
}
virtualWidth = actualWidth = m_surface->w;
virtualHeight = actualHeight = m_surface->h;
if (m_potExtend) {
// extend to power-of-two if necessary
actualWidth = ceil_pow2(m_surface->w);
actualHeight = ceil_pow2(m_surface->h);
if (actualWidth != virtualWidth || actualHeight != virtualHeight) {
if(m_textureType == TEXTURE_2D) {
SDL_Surface *s = SDL_CreateRGBSurface(SDL_SWSURFACE, actualWidth, actualHeight, targetPixelFormat->BitsPerPixel,
targetPixelFormat->Rmask, targetPixelFormat->Gmask, targetPixelFormat->Bmask, targetPixelFormat->Amask);
SDL_SetSurfaceBlendMode(m_surface.Get(), SDL_BLENDMODE_NONE);
SDL_BlitSurface(m_surface.Get(), 0, s, 0);
m_surface = SDLSurfacePtr::WrapNew(s);
} else if(m_textureType == TEXTURE_CUBE_MAP) {
assert(m_cubemap.size() == 6);
for(unsigned int i = 0; i < 6; ++i) {
SDL_Surface *s = SDL_CreateRGBSurface(SDL_SWSURFACE, actualWidth, actualHeight, targetPixelFormat->BitsPerPixel,
targetPixelFormat->Rmask, targetPixelFormat->Gmask, targetPixelFormat->Bmask, targetPixelFormat->Amask);
SDL_SetSurfaceBlendMode(m_cubemap[i].Get(), SDL_BLENDMODE_NONE);
SDL_BlitSurface(m_cubemap[i].Get(), 0, s, 0);
m_cubemap[i] = SDLSurfacePtr::WrapNew(s);
}
} else {
assert(0);
}
}
}
else if (! m_filename.empty()) {
// power-of-two check
unsigned long width = ceil_pow2(m_surface->w);
unsigned long height = ceil_pow2(m_surface->h);
if (width != virtualWidth || height != virtualHeight)
Output("WARNING: texture '%s' is not power-of-two and may not display correctly\n", m_filename.c_str());
}
} else {
switch(m_dds.GetTextureFormat()) {
case PicoDDS::FORMAT_DXT1: targetTextureFormat = TEXTURE_DXT1; break;
case PicoDDS::FORMAT_DXT5: targetTextureFormat = TEXTURE_DXT5; break;
default:
Output("ERROR: DDS texture with invalid format '%s' (only DXT1 and DXT5 are supported)\n", m_filename.c_str());
assert(false);
return;
}
virtualWidth = actualWidth = m_dds.imgdata_.width;
virtualHeight = actualHeight = m_dds.imgdata_.height;
numberOfMipMaps = m_dds.imgdata_.numMipMaps;
numberOfImages = m_dds.imgdata_.numImages;
if(m_textureType == TEXTURE_CUBE_MAP) {
// Cube map must be fully defined (6 images) to be used correctly
assert(numberOfImages == 6);
}
}
m_descriptor = TextureDescriptor(
targetTextureFormat,
vector2f(actualWidth,actualHeight),
vector2f(float(virtualWidth)/float(actualWidth),float(virtualHeight)/float(actualHeight)),
m_sampleMode, m_generateMipmaps, m_compressTextures, m_anisotropicFiltering, numberOfMipMaps, m_textureType);
m_prepared = true;
}
bool VideoDriver_SDL::CreateMainSurface(uint w, uint h)
{
SDL_Surface *newscreen, *icon;
char caption[50];
int bpp = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
bool want_hwpalette;
GetAvailableVideoMode(&w, &h);
DEBUG(driver, 1, "SDL: using mode %ux%ux%d", w, h, bpp);
if (bpp == 0) usererror("Can't use a blitter that blits 0 bpp for normal visuals");
char icon_path[MAX_PATH];
if (FioFindFullPath(icon_path, lastof(icon_path), BASESET_DIR, "openttd.32.bmp") != NULL) {
/* Give the application an icon */
icon = SDL_CALL SDL_LoadBMP(icon_path);
if (icon != NULL) {
/* Get the colourkey, which will be magenta */
uint32 rgbmap = SDL_CALL SDL_MapRGB(icon->format, 255, 0, 255);
SDL_CALL SDL_SetColorKey(icon, SDL_SRCCOLORKEY, rgbmap);
SDL_CALL SDL_WM_SetIcon(icon, NULL);
SDL_CALL SDL_FreeSurface(icon);
}
}
if (_use_hwpalette == 2) {
/* Default is to autodetect when to use SDL_HWPALETTE.
* In this case, SDL_HWPALETTE is only used for 8bpp
* blitters in fullscreen.
*
* When using an 8bpp blitter on a 8bpp system in
* windowed mode with SDL_HWPALETTE, OpenTTD will claim
* the system palette, making all other applications
* get the wrong colours. In this case, we're better of
* trying to approximate the colors we need using system
* colors, using a shadow surface (see below).
*
* On a 32bpp system, SDL_HWPALETTE is ignored, so it
* doesn't matter what we do.
*
* When using a 32bpp blitter on a 8bpp system, setting
* SDL_HWPALETTE messes up rendering (at least on X11),
* so we don't do that. In this case, SDL takes care of
* color approximation using its own shadow surface
* (which we can't force in 8bpp on 8bpp mode,
* unfortunately).
*/
want_hwpalette = bpp == 8 && _fullscreen && _support8bpp == S8BPP_HARDWARE;
} else {
/* User specified a value manually */
want_hwpalette = _use_hwpalette;
}
if (want_hwpalette) DEBUG(driver, 1, "SDL: requesting hardware palete");
/* Free any previously allocated shadow surface */
if (_sdl_screen != NULL && _sdl_screen != _sdl_realscreen) SDL_CALL SDL_FreeSurface(_sdl_screen);
if (_sdl_realscreen != NULL) {
if (_requested_hwpalette != want_hwpalette) {
/* SDL (at least the X11 driver), reuses the
* same window and palette settings when the bpp
* (and a few flags) are the same. Since we need
* to hwpalette value to change (in particular
* when switching between fullscreen and
* windowed), we restart the entire video
* subsystem to force creating a new window.
*/
DEBUG(driver, 0, "SDL: Restarting SDL video subsystem, to force hwpalette change");
SDL_CALL SDL_QuitSubSystem(SDL_INIT_VIDEO);
SDL_CALL SDL_InitSubSystem(SDL_INIT_VIDEO);
ClaimMousePointer();
SetupKeyboard();
}
}
/* Remember if we wanted a hwpalette. We can't reliably query
* SDL for the SDL_HWPALETTE flag, since it might get set even
* though we didn't ask for it (when SDL creates a shadow
* surface, for example). */
_requested_hwpalette = want_hwpalette;
/* DO NOT CHANGE TO HWSURFACE, IT DOES NOT WORK */
newscreen = SDL_CALL SDL_SetVideoMode(w, h, bpp, SDL_SWSURFACE | (want_hwpalette ? SDL_HWPALETTE : 0) | (_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE));
if (newscreen == NULL) {
DEBUG(driver, 0, "SDL: Couldn't allocate a window to draw on");
return false;
}
_sdl_realscreen = newscreen;
if (bpp == 8 && (_sdl_realscreen->flags & SDL_HWPALETTE) != SDL_HWPALETTE) {
/* Using an 8bpp blitter, if we didn't get a hardware
* palette (most likely because we didn't request one,
* see above), we'll have to set up a shadow surface to
* render on.
*
* Our palette will be applied to this shadow surface,
* while the real screen surface will use the shared
* system palette (which will partly contain our colors,
* but most likely will not have enough free color cells
* for all of our colors). SDL can use these two
* palettes at blit time to approximate colors used in
* the shadow surface using system colors automatically.
*
* Note that when using an 8bpp blitter on a 32bpp
* system, SDL will create an internal shadow surface.
* This shadow surface will have SDL_HWPALLETE set, so
* we won't create a second shadow surface in this case.
*/
DEBUG(driver, 1, "SDL: using shadow surface");
newscreen = SDL_CALL SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, bpp, 0, 0, 0, 0);
if (newscreen == NULL) {
DEBUG(driver, 0, "SDL: Couldn't allocate a shadow surface to draw on");
return false;
}
}
/* Delay drawing for this cycle; the next cycle will redraw the whole screen */
_num_dirty_rects = 0;
_screen.width = newscreen->w;
_screen.height = newscreen->h;
_screen.pitch = newscreen->pitch / (bpp / 8);
_screen.dst_ptr = newscreen->pixels;
_sdl_screen = newscreen;
/* When in full screen, we will always have the mouse cursor
* within the window, even though SDL does not give us the
* appropriate event to know this. */
if (_fullscreen) _cursor.in_window = true;
Blitter *blitter = BlitterFactory::GetCurrentBlitter();
blitter->PostResize();
InitPalette();
switch (blitter->UsePaletteAnimation()) {
case Blitter::PALETTE_ANIMATION_NONE:
case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:
UpdatePalette();
break;
case Blitter::PALETTE_ANIMATION_BLITTER:
if (VideoDriver::GetInstance() != NULL) blitter->PaletteAnimate(_local_palette);
break;
default:
NOT_REACHED();
}
seprintf(caption, lastof(caption), "OpenTTD %s", _openttd_revision);
SDL_CALL SDL_WM_SetCaption(caption, caption);
GameSizeChanged();
return true;
}
void Tankas::atnaujinti(int xp, int yp, vector<Kulka*> &kulkos)
{
if(sprogsta)
{
Sprogimas();
return;
}
int dx, dy;
dx = X+Tanks->w/2 - xp;
dy = Y+Tanks->h/2 - yp;
vk = atan2(dx , dy) * 180 / M_PI;
pk = vk - kampas + 90;
// if( kulkos != NULL )
{
int i = 0;
while(i < kulkos.size())
{
// cout<<"kulkos x"<<kulkos[i]->GetX()<<endl;
if( SDL_CollidePixel(rotation, X, Y, kulkos[i]->KPasukta, kulkos[i]->GetX(), kulkos[i]->GetY()) != 0 )
{
/*I mane pataike!*/
sprogsta = true;
lastW=rotation->w;
lastH=rotation->h;
cout<<"Pataike!"<<endl;
}
i++;
}
}
if(senas_kampas!=kampas || senas_kampasP != pk)
{
SDL_Surface* Tn = new SDL_Surface; //Tanko vamzdis
SDL_Surface* ND = new SDL_Surface; //Laikinas sluoksnis
SDL_Surface* Tm = new SDL_Surface; //Originaliojo tanko sluoksnio kopija
//-----------------------------------------------------------------------------
ND = SDL_CreateRGBSurface(SDL_HWSURFACE|SDL_SRCALPHA, Tanks->w, Tanks->h, 32, NULL, NULL, NULL, 0);
SDL_BlitSurface(Tanks, NULL, ND, NULL);
Uint32 colorkey1 = SDL_MapRGB( Tanks->format, 0, 255, 0 );
SDL_SetColorKey( ND, SDL_SRCCOLORKEY, colorkey1 );//naujai sukurtam sluoksniu nustatom sena color key
Tm = SDL_DisplayFormatAlpha( ND );
std::swap(Tm, ND);
SDL_FreeSurface(ND);
//delete(ND);
//-----------------------------------------------------------------------------
Tn = rotozoomSurfaceXY(Patranka, pk, 1, 1, 0);
SDL_Rect dst = {Tn->w / 2, Tn->h / 2};
dst.x = ( Tanks->w - Tn->w ) / 2;
dst.y = ( Tanks->h - Tn->h ) / 2;
SDL_BlitSurface(Tn, NULL, Tm, &dst);
SDL_FreeSurface(Tn);
//delete(Tn);
SDL_FreeSurface(rotation);
rotation = rotozoomSurface(Tm, kampas, 0.45, 0);
SDL_FreeSurface(Tm);
//delete(Tm);
Uint32 colorkey = SDL_MapRGB( rotation->format, 0, 255, 0 );
SDL_SetColorKey( rotation, SDL_SRCCOLORKEY, colorkey );
SDL_Surface * www = new SDL_Surface;
www = SDL_DisplayFormatAlpha(rotation);
std::swap(www, rotation);
SDL_FreeSurface(www);
//delete(www);
senas_kampas = kampas;
senas_kampasP = pk;
}
}
