diff options
Diffstat (limited to 'backends/gp32/gp32.cpp')
| -rw-r--r-- | backends/gp32/gp32.cpp | 3469 |
1 files changed, 2578 insertions, 891 deletions
diff --git a/backends/gp32/gp32.cpp b/backends/gp32/gp32.cpp index 844ec5ace6..c8912ed166 100644 --- a/backends/gp32/gp32.cpp +++ b/backends/gp32/gp32.cpp @@ -1,7 +1,8 @@ /* ScummVM - Scumm Interpreter * Copyright (C) 2001 Ludvig Strigeus - * Copyright (C) 2001/2002 The ScummVM project - * Copyright (C) 2002 ph0x (GP32 port) + * Copyright (C) 2001/2004 The ScummVM project + * Copyright (C) 2002 Ph0x - GP32 Backend + * Copyright (C) 2003/2004 DJWillis - GP32 Backend * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -16,35 +17,194 @@ * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +/* + * + * Main Source for ScummVM for the GP32 + * */ +// TODO: +// Clean up GP leftovers and strip backend to only bits the GP32 needs. +// Finish restructure. +// Sort all remaining GCC 3.4 warnings. +// setTimerCallback: function call doesnt use * ? + +//#define REAL_MAIN + +#ifdef GP32_GDB +#include <gdb-stub.h> +#endif /*GP32_GDB */ + +#include "backends/gp32/setup.h" + +#include "backends/gp32/gp32.h" + +#include "backends/gp32/gfx_splash.h" +//#include "backends/gp32/resources/gfx_splash_alt.h" -//#define GPDEBUG //uncomment for debug messages (use DarkFader's emudebug.exe) -#include "gp32.h" +#define gpRGB16(r,g,b) (((((r)>>3)&0x1F) << 11) | ((((g)>>3)&0x1F) << 6) | (((b)>>3)&0x1F)<<1) +#define RGB_TO_16(r,g,b) (((((r)>>3)&0x1F) << 11) | ((((g)>>3)&0x1F) << 6) | (((b)>>3)&0x1F)<<1) + +int nflip, keydata; // Flip Index +GP_HPALETTE PAL; //palette +GPDRAWSURFACE LCDbuffer[BUFFERCOUNT + 1]; //buffers -#define MARK printf("%s, %s, %d", __FUNCTION__, __FILE__, __LINE__) //ph0x -#define GP_RGB16(r,g,b) (((((r>>3))&0x1f)<<11)|((((g>>3))&0x1f)<<6)|((((b>>3))&0x1f)<<1)) void GpSetPaletteEntry(u8 i, u8 r, u8 g, u8 b); -#define GAME_SURFACE 0 -#define NAMEME_SURFACE 1 -#define DEBUG_SURFACE 2 +// FIXME: No global init! + +float gammatab[256], gammatab2[256]; // fixme: one table +const float scrGamma[] = { 1.0, 1.001, 1.002, 1.003, 1.004, 1.005 }; +char gindex = 3; + +int mx = 1, my = 1; +int scrofsy = 239; +char currentsurf; + +// FIXME!! +// crashes if here and not buildgammatab() not called as very first line! check +// check if sav file handling overwrites something! +// float gammatab[256]; -GPDRAWSURFACE gpDraw[3]; // surfaces -int mx=1, my=1; // wrong if 0? -char currsurface; FILE *fstderr, *fstdout, *fstdin; -// Set colors of the palette -void OSystem_GP32::setPalette(const byte *colors, uint start, uint num) { +/**************************************************************** + GP32 Input mappings - Returns Button Pressed. +****************************************************************/ +int gpTrapKey(void) +{ + int value = 0; + +#define rKEY_A 0x4000 +#define rKEY_B 0x2000 +#define rKEY_L 0x1000 +#define rKEY_R 0x8000 +#define rKEY_UP 0x0800 +#define rKEY_DOWN 0x0200 +#define rKEY_LEFT 0x0100 +#define rKEY_RIGHT 0x0400 +#define rKEY_START 0x0040 +#define rKEY_SELECT 0x0080 +#define rPBDAT (*(volatile unsigned *)0x1560000c) +#define rPEDAT (*(volatile unsigned *)0x15600030) + + unsigned long gpb = rPBDAT; // 0x156 + unsigned long gpe = rPEDAT; + + if ((gpb & rKEY_LEFT) == 0) + value |= GPC_VK_LEFT; + if ((gpb & rKEY_RIGHT) == 0) + value |= GPC_VK_RIGHT; + if ((gpb & rKEY_UP) == 0) + value |= GPC_VK_UP; + if ((gpb & rKEY_DOWN) == 0) + value |= GPC_VK_DOWN; + if ((gpb & rKEY_A) == 0) + value |= GPC_VK_FA; + if ((gpb & rKEY_B) == 0) + value |= GPC_VK_FB; + if ((gpb & rKEY_L) == 0) + value |= GPC_VK_FL; + if ((gpb & rKEY_R) == 0) + value |= GPC_VK_FR; + if ((gpe & rKEY_SELECT) == 0) + value |= GPC_VK_SELECT; + if ((gpe & rKEY_START) == 0) + value |= GPC_VK_START; + + return value; +} + +/**************************************************************** + GP32 ScummVM OSystem Implementation. +****************************************************************/ + +//OSystem *OSystem_GP32::create() +//{ +// //OSystem_GP32 *syst = new OSystem_GP32(); +// //return syst; +// return new OSystem_GP32(); +//} + +OSystem *OSystem_GP32_create() +{ +// +// OSystem_GP32 *syst = new OSystem_GP32(); +//// +//// //syst->_mode = gfx_mode; +//// //syst->_full_screen = full_screen; +// +// // allocate palette storage +// syst->_currentPalette = (gpColor*)calloc(sizeof(gpColor), 256); +// +// // allocate the dirty rect storage +// syst->_mouseBackup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2); +// return syst; +// return new OSystem_GP32(); + + //return OSystem_GP32::create(); + return new OSystem_GP32(); +} + +OSystem_GP32::OSystem_GP32() : +//#ifdef USE_OSD +// _osdSurface(0), _osdAlpha(SDL_ALPHA_TRANSPARENT), _osdFadeStartTime(0), +//#endif + _hwscreen(0), _screen(0), _screenWidth(0), _screenHeight(0), + _tmpscreen(0), _overlayVisible(false), +// _cdrom(0), +// _scaler_proc(0), + _modeChanged(false), _dirty_checksums(0), + _mouseVisible(false), _mouseDrawn(false), _mouseData(0), + _mouseHotspotX(0), _mouseHotspotY(0), + _currentShakePos(0), _newShakePos(0), + _paletteDirtyStart(0), _paletteDirtyEnd(0), _graphicsMutex(0) { + + // allocate palette storage + _currentPalette = (gpColor *) calloc(sizeof(gpColor), 256); + + // allocate the dirty rect storage + _mouseBackup = + (byte *) malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2); + + // reset mouse state + memset(&km, 0, sizeof(km)); + + _scaleFactor = 1; + _scaler_proc = Normal1x; + + _mode = GFX_NORMAL; + _full_screen = true; + _adjustAspectRatio = false; + _mode_flags = 0; + + //init_intern(); +} + +OSystem_GP32::~OSystem_GP32() { + if (_dirty_checksums) + free(_dirty_checksums); + free(_currentPalette); + free(_mouseBackup); + deleteMutex(_graphicsMutex); + quit(); +} + +// Set colors of the palette +void OSystem_GP32::setPalette(const byte * colors, uint start, uint num) { const byte *b = colors; uint i; - SDL_Color *base = _currentPalette + start; - for(i = 0; i < num; i++) { + gpColor *base = _currentPalette + start; + for (i = 0; i < num; i++) { base[i].r = b[0]; base[i].g = b[1]; base[i].b = b[2]; - b += 4; + b += 4; } if (start < _paletteDirtyStart) @@ -54,24 +214,51 @@ void OSystem_GP32::setPalette(const byte *colors, uint start, uint num) { _paletteDirtyEnd = start + num; } -// Set the size of the video bitmap. -// Typically, 320x200 -void OSystem_GP32::initSize(uint w, uint h) { - // Avoid redundant res changes +// Set the size of the video bitmap. +// Typically, 320x200 (x240 for FMTowns) + +// FIXME: Is there a clean way to get the Game_ID in the backend, I still like the virual keymap feature below. +//#include "base/gameDetector.h" +//#include "scumm/scumm.h" +//extern ScummEngine *g_scumm; + +const char shortkey0[] = ""; +const char shortkey1[] = "gpuolscty"; // give, pick up, use, open, look at, push, close, talk to, pull +const char shortkey2[] = "qwerasdfzxcv"; //push, open, walk to, use, pull, close, pick up, turn on, give, look, what is, turn off +const char shortkey3[] = "wlptuo"; // samnmax +const char *shortkey; +int skindex = 0; + +void OSystem_GP32::initSize(uint w, uint h) { + /*switch (menu[MENU_SCREENPOS].index) { + * case 0 : scrofsy = 239 - (240 - h)/2; break; + * case 1 : scrofsy = 239; break; + * } + */ + //switch (g_scumm->_gameId) { //fixme: add all + // case GID_TENTACLE : case GID_MONKEY2 : case GID_INDY4 : shortkey=shortkey1; break; + // case GID_INDY3 : case GID_ZAK256 : case GID_MONKEY : shortkey=shortkey2; break; + // case GID_SAMNMAX : shortkey=shortkey3; break; + // default : shortkey=shortkey0; break; + //} + + shortkey = shortkey0; + + // Avoid redundant res changes if ((int)w == _screenWidth && (int)h == _screenHeight) return; _screenWidth = w; _screenHeight = h; - CKSUM_NUM = (_screenWidth*_screenHeight/(8*8)); + CKSUM_NUM = (_screenWidth * _screenHeight / (8 * 8)); if (_dirty_checksums) free(_dirty_checksums); - _dirty_checksums = (uint32*)calloc(CKSUM_NUM*2, sizeof(uint32)); - _mouseData = NULL; + _dirty_checksums = (uint32 *) calloc(CKSUM_NUM * 2, sizeof(uint32)); + _mouseData = NULL; unload_gfx_mode(); load_gfx_mode(); - + return; } void OSystem_GP32::add_dirty_rect(int x, int y, int w, int h) { @@ -81,23 +268,32 @@ void OSystem_GP32::add_dirty_rect(int x, int y, int w, int h) { if (_num_dirty_rects == NUM_DIRTY_RECT) _forceFull = true; else { - SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++]; - - // Extend the dirty region by 1 pixel for scalers - // that "smear" the screen, e.g. 2xSAI + gpRect *r = &_dirty_rect_list[_num_dirty_rects++]; + + // Extend the dirty region by 1 pixel for scalers + // that "smear" the screen, e.g. 2xSAI if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) { x--; y--; - w+=2; - h+=2; + w += 2; + h += 2; } - // clip - if (x < 0) { w+=x; x=0; } - if (y < 0) { h+=y; y=0; } - if (w > _screenWidth-x) { w = _screenWidth - x; } - if (h > _screenHeight-y) { h = _screenHeight - y; } - + if (x < 0) { + w += x; + x = 0; + } + if (y < 0) { + h += y; + y = 0; + } + if (w > _screenWidth - x) { + w = _screenWidth - x; + } + if (h > _screenHeight - y) { + h = _screenHeight - y; + } + r->x = x; r->y = y; r->w = w; @@ -105,45 +301,46 @@ void OSystem_GP32::add_dirty_rect(int x, int y, int w, int h) { } } -#define ROL(a,n) a = (a<<(n)) | (a>>(32-(n))) -#define DOLINE(x) a ^= ((uint32*)buf)[0+(x)*(_screenWidth/4)]; b ^= ((uint32*)buf)[1+(x)*(_screenWidth/4)] void OSystem_GP32::mk_checksums(const byte *buf) { uint32 *sums = _dirty_checksums; - uint x,y; - const uint last_x = (uint)_screenWidth/8; - const uint last_y = (uint)_screenHeight/8; + uint x, y; + const uint last_x = (uint) _screenWidth / 8; + const uint last_y = (uint) _screenHeight / 8; + + const uint BASE = 65521; /* largest prime smaller than 65536 */ /* the 8x8 blocks in buf are enumerated starting in the top left corner and * reading each line at a time from left to right */ - for(y=0; y != last_y; y++, buf+=_screenWidth*(8-1)) - for(x=0; x != last_x; x++, buf+=8) { - uint32 a = x; - uint32 b = y; - - DOLINE(0); ROL(a,13); ROL(b,11); - DOLINE(2); ROL(a,13); ROL(b,11); - DOLINE(4); ROL(a,13); ROL(b,11); - DOLINE(6); ROL(a,13); ROL(b,11); - - a*=0xDEADBEEF; - b*=0xBAADF00D; + for (y = 0; y != last_y; y++, buf += _screenWidth * (8 - 1)) + for (x = 0; x != last_x; x++, buf += 8) { + // Adler32 checksum algorithm (from RFC1950, used by gzip and zlib). + // This computes the Adler32 checksum of a 8x8 pixel block. Note + // that we can do the modulo operation (which is the slowest part) + // of the algorithm) at the end, instead of doing each iteration, + // since we only have 64 iterations in total - and thus s1 and + // s2 can't overflow anyway. + uint32 s1 = 1; + uint32 s2 = 0; + const byte *ptr = buf; + for (int subY = 0; subY < 8; subY++) { + for (int subX = 0; subX < 8; subX++) { + s1 += ptr[subX]; + s2 += s1; + } + ptr += _screenWidth; + } - DOLINE(1); ROL(a,13); ROL(b,11); - DOLINE(3); ROL(a,13); ROL(b,11); - DOLINE(5); ROL(a,13); ROL(b,11); - DOLINE(7); ROL(a,13); ROL(b,11); + s1 %= BASE; + s2 %= BASE; /* output the checksum for this block */ - *sums++=a+b; + *sums++ = (s2 << 16) + s1; } } -#undef DOLINE -#undef ROL - void OSystem_GP32::add_dirty_rgn_auto(const byte *buf) { - assert( ((uint32)buf & 3) == 0); - + assert(((uint32) buf & 3) == 0); + /* generate a table of the checksums */ mk_checksums(buf); @@ -153,24 +350,25 @@ void OSystem_GP32::add_dirty_rgn_auto(const byte *buf) { } /* go through the checksum list, compare it with the previous checksums, - and add all dirty rectangles to a list. try to combine small rectangles - into bigger ones in a simple way */ + * and add all dirty rectangles to a list. try to combine small rectangles + * into bigger ones in a simple way */ if (!_forceFull) { - int x,y,w; + int x, y, w; uint32 *ck = _dirty_checksums; - - for(y=0; y!=_screenHeight/8; y++) { - for(x=0; x!=_screenWidth/8; x++,ck++) { + + for (y = 0; y != _screenHeight / 8; y++) { + for (x = 0; x != _screenWidth / 8; x++, ck++) { if (ck[0] != ck[CKSUM_NUM]) { /* found a dirty 8x8 block, now go as far to the right as possible, - and at the same time, unmark the dirty status by setting old to new. */ - w=0; + * and at the same time, unmark the dirty status by setting old to new. */ + w = 0; do { - ck[w+CKSUM_NUM] = ck[w]; + ck[w + CKSUM_NUM] = ck[w]; w++; - } while (x+w != _screenWidth/8 && ck[w] != ck[w+CKSUM_NUM]); - - add_dirty_rect(x*8, y*8, w*8, 8); + } while (x + w != _screenWidth / 8 + && ck[w] != ck[w + CKSUM_NUM]); + + add_dirty_rect(x * 8, y * 8, w * 8, 8); if (_forceFull) goto get_out; @@ -178,30 +376,45 @@ void OSystem_GP32::add_dirty_rgn_auto(const byte *buf) { } } } else { - get_out:; + get_out:; /* Copy old checksums to new */ - memcpy(_dirty_checksums + CKSUM_NUM, _dirty_checksums, CKSUM_NUM * sizeof(uint32)); + memcpy(_dirty_checksums + CKSUM_NUM, _dirty_checksums, + CKSUM_NUM * sizeof(uint32)); } } // Draw a bitmap to screen. // The screen will not be updated to reflect the new bitmap -void OSystem_GP32::copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) { +void OSystem_GP32::copyRectToScreen(const byte *buf, int pitch, int x, int y, + int w, int h) { if (_screen == NULL) return; - if (pitch == _screenWidth && x==0 && y==0 && w==_screenWidth && h==_screenHeight && _mode_flags&DF_WANT_RECT_OPTIM) { + if (pitch == _screenWidth && x == 0 && y == 0 && w == _screenWidth + && h == _screenHeight && _mode_flags & DF_WANT_RECT_OPTIM) { /* Special, optimized case for full screen updates. * It tries to determine what areas were actually changed, * and just updates those, on the actual display. */ add_dirty_rgn_auto(buf); } else { /* Clip the coordinates */ - if (x < 0) { w+=x; buf-=x; x = 0; } - if (y < 0) { h+=y; buf-=y*pitch; y = 0; } - if (w > _screenWidth-x) { w = _screenWidth - x; } - if (h > _screenHeight-y) { h = _screenHeight - y; } - + if (x < 0) { + w += x; + buf -= x; + x = 0; + } + if (y < 0) { + h += y; + buf -= y * pitch; + y = 0; + } + if (w > _screenWidth - x) { + w = _screenWidth - x; + } + if (h > _screenHeight - y) { + h = _screenHeight - y; + } + if (w <= 0 || h <= 0) return; @@ -213,162 +426,243 @@ void OSystem_GP32::copyRectToScreen(const byte *buf, int pitch, int x, int y, in if (_mouseDrawn) undraw_mouse(); - ///if (SDL_LockSurface(_screen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); - - byte *dst = (byte *)_screen->pixels + y * _screenWidth + x; + byte *dst = (byte *) _screen->pixels + y * _screenWidth + x; do { memcpy(dst, buf, w); dst += _screenWidth; buf += pitch; } while (--h); - - ///SDL_UnlockSurface(_screen); } +gpSurface *gpCreateRGBSurface(Uint32 flags, int width, int height, int depth, + Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) { -SDL_Surface *SDL_CreateRGBSurface - (Uint32 flags, int width, int height, int depth, - Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) { - - SDL_Surface *surf = (SDL_Surface*)malloc(sizeof(SDL_Surface)); - surf->format = (SDL_PixelFormat*)malloc(sizeof(SDL_PixelFormat)); + gpSurface *surf = (gpSurface *) malloc(sizeof(gpSurface)); + surf->format = (gpPixelFormat *) malloc(sizeof(gpPixelFormat)); - if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) { - error(">HW surface (w=%d, h=%d)", width, height); - } else - if ((flags & SDL_SWSURFACE) == SDL_SWSURFACE) { - int size=width*height*(depth/8); - printf(">SW surface (w=%d, h=%d, size=%d, depth=%d)", width, height, size, depth); + if ((flags & gpHWSurface) == gpHWSurface) { + error(">HW surface (w=%d, h=%d)", width, height); + } else if ((flags & gpSWSurface) == gpSWSurface) { + int size = width * height * (depth / 8); + printf(">SW surface (w=%d, h=%d, size=%d, depth=%d)", width, + height, size, depth); surf->pixels = malloc(size); } else { error(">unknown surface", width, height); return NULL; - } - surf->w=width; - surf->h=height; - surf->pitch=width*(depth/8); - surf->format->BitsPerPixel=depth; - surf->format->BytesPerPixel=depth/8; + } + surf->w = width; + surf->h = height; + surf->pitch = width * (depth / 8); + surf->format->BitsPerPixel = depth; + surf->format->BytesPerPixel = depth / 8; return surf; } -SDL_Surface *SDL_SetVideoMode - (int width, int height, int bpp, Uint32 flags) { - - return SDL_CreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0); +gpSurface *gpSetVideoMode(int width, int height, int bpp, Uint32 flags) { + return gpCreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0); } -void SDL_FreeSurface(SDL_Surface *surface) { +void gpFreeSurface(gpSurface *surface) { // implement } -SDL_Surface *SDL_CreateRGBSurfaceFrom(void *pixels, - int width, int height, int depth, int pitch, - Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) { +gpSurface *gpCreateRGBSurfaceFrom(void *pixels, + int width, int height, int depth, int pitch, + Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) { // FIXME dont reuse code - SDL_Surface *surf = (SDL_Surface*)malloc(sizeof(SDL_Surface)); - surf->format = (SDL_PixelFormat*)malloc(sizeof(SDL_PixelFormat)); + gpSurface *surf = (gpSurface *) malloc(sizeof(gpSurface)); + surf->format = (gpPixelFormat *) malloc(sizeof(gpPixelFormat)); - surf->w=width; - surf->h=height; - surf->pitch=pitch; - surf->pixels=pixels; - surf->format->BitsPerPixel=depth; - surf->format->BytesPerPixel=depth/8; + surf->w = width; + surf->h = height; + surf->pitch = pitch; + surf->pixels = pixels; + surf->format->BitsPerPixel = depth; + surf->format->BytesPerPixel = depth / 8; return surf; } -int SDL_FillRect - (SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color) { - - // implement +int gpFillRect(gpSurface *dst, gpRect *dstrect, Uint32 color) { + // FIXME: implement return 0; } +int mcshake = 0; -void SDL_UpdateRects(SDL_Surface *screen, int numrects, SDL_Rect *rects) { - +void gpUpdateRects(gpSurface *screen, int numrects, gpRect *rects) { // FIXME dont duplicate code :) + // CHECK: shake causes crash? mcshake can get negative? + + if (screen->format->BitsPerPixel == 8) + while (numrects--) { + //if (mcshake && rects->h == LCD_HEIGHT) { //fixme? + if (mcshake && rects->h == /*_screenHeight*/ 200) { //fixme? + //printf("shaking %d", mcshake); + rects->h -= mcshake; + GpRectFill(NULL, &LCDbuffer[GAME_SURFACE], 0, rects->h + scrofsy, 320, mcshake, 0); //black border + } - if (screen->format->BitsPerPixel==8) - while (numrects--) { - u8 *s=(u8*)((u8*)screen->pixels+rects->y*320+rects->x); - u8 *d=(u8*)((u8*)gpDraw[GAME_SURFACE].ptbuffer+rects->x*240+239-rects->y); - u8 *s2=s, *d2=d; - - for (int x=rects->w; x; x--) { - for (int y=rects->h; y; y--) { - *d--=*s; - s+=320; // FIXME? screen->pitch; + u8 *s = + (u8 *) ((u8 *) screen->pixels + (rects->y + + mcshake) * 320 + rects->x); + u8 *d = + (u8 *) ((u8 *) LCDbuffer[GAME_SURFACE].ptbuffer + + rects->x * 240 + scrofsy - rects->y); + u8 *s2 = s, *d2 = d; + + for (int x = rects->w; x; x--) { + for (int y = rects->h; y; y--) { + *d-- = *s; + s += 320; // FIXME? screen->pitch; + } + d2 += 240; + d = d2; + s2++; + s = s2; } - d2+=240; - d=d2; - s2++; - s=s2; - } - rects++; - } - else - if (screen->format->BitsPerPixel==16) - while (numrects--) { - u16 *s=(u16*)((u16*)screen->pixels+rects->y*320+rects->x); - u16 *d=(u16*)((u16*)gpDraw[GAME_SURFACE].ptbuffer+rects->x*240+239-rects->y); - u16 *s2=s, *d2=d; - - for (int x=rects->w; x; x--) { - for (int y=rects->h; y; y--) { - *d--=*s; - s+=320; // FIXME? screen->pitch; + rects++; + } else if (screen->format->BitsPerPixel == 16) + while (numrects--) { + u16 *s = + (u16 *) ((u16 *) screen->pixels + rects->y * 320 + + rects->x); + u16 *d = + (u16 *) ((u16 *) LCDbuffer[GAME_SURFACE].ptbuffer + + rects->x * 240 + scrofsy - rects->y); + u16 *s2 = s, *d2 = d; + + for (int x = rects->w; x; x--) { + for (int y = rects->h; y; y--) { + *d-- = *s; + s += 320; // FIXME? screen->pitch; + } + d2 += 240; + d = d2; + s2++; + s = s2; } - d2+=240; - d=d2; - s2++; - s=s2; - } - rects++; - } - else error("blitting surface with wrong depth (%d)", screen->format->BitsPerPixel); + rects++; + } else + error("blitting surface with wrong depth (%d)", + screen->format->BitsPerPixel); // eh? works also when rects++ is here?? } -//#define SDL_BlitSurface SDL_UpperBlit -int SDL_BlitSurface(SDL_Surface *screen, SDL_Rect *rects, - SDL_Surface *dst, SDL_Rect *dstrect) { - +//#define gpBlitSurface gpUpperBlit +int gpBlitSurface(gpSurface *screen, gpRect *rects, gpSurface *dst, gpRect *dstrect) { // FIXME? role?? - //SDL_UpdateRects(screen, 1, rects); //ph0x! sdl_hwscreen + //gpUpdateRects(screen, 1, rects); //ph0x! _hwscreen return 0; } -int SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors) { - if (currsurface == DEBUG_SURFACE) return 1; +int gpSetColors(gpSurface *surface, gpColor *colors, int firstcolor, int ncolors) { + float rr, gg, bb; + gpColor colors2[256]; - GpPaletteEntryChangeEx(firstcolor, ncolors, (GP_LOGPALENTRY*)colors, 0); + if (currentsurf == DEBUG_SURFACE) + return 1; + + for (int i = firstcolor; i < firstcolor + ncolors; i++) { + rr = colors[i].r * gammatab[colors[i].r]; + gg = colors[i].g * gammatab[colors[i].g]; + bb = colors[i].b * gammatab[colors[i].b]; + + if (rr > 255) + rr = 255; + if (gg > 255) + gg = 255; + if (bb > 255) + bb = 255; + + colors2[i].r = (u8) rr; + colors2[i].g = (u8) gg; + colors2[i].b = (u8) bb; + } + + GpPaletteEntryChangeEx(firstcolor, ncolors, (GP_LOGPALENTRY *) colors2, + 0); return 1; } +// Moves the screen content around by the given amount of pixels +// but only the top height pixel rows, the rest stays untouched +//void OSystem_GP32::move_screen(int dx, int dy, int height) +//{ +// if ((dx == 0) && (dy == 0)) +// return; +// +// if (dx == 0) { +// // vertical movement +// if (dy > 0) { +// // move down +// // copy from bottom to top +// for (int y = height - 1; y >= dy; y--) +// copyRectToScreen((byte *)_screen->pixels + _screenWidth * (y - dy), _screenWidth, 0, y, _screenWidth, 1); +// } else { +// // move up +// // copy from top to bottom +// for (int y = 0; y < height + dx; y++) +// copyRectToScreen((byte *)_screen->pixels + _screenWidth * (y - dy), _screenWidth, 0, y, _screenWidth, 1); +// } +// } else if (dy == 0) { +// // horizontal movement +// if (dx > 0) { +// // move right +// // copy from right to left +// for (int x = _screenWidth - 1; x >= dx; x--) +// copyRectToScreen((byte *)_screen->pixels + x - dx, _screenWidth, x, 0, 1, height); +// } else { +// // move left +// // copy from left to right +// for (int x = 0; x < _screenWidth; x++) +// copyRectToScreen((byte *)_screen->pixels + x - dx, _screenWidth, x, 0, 1, height); +// } +// } else { +// // free movement +// // not necessary for now +// } +//} + +int16 OSystem_GP32::get_height() { + return _screenHeight; +} + +int16 OSystem_GP32::get_width() { + return _screenWidth; +} + +//void OSystem_GP32::warpMouse(int, int) +//{ +//} + +void OSystem_GP32::warpMouse(int x, int y) { +// set_mouse_pos(x, y); +} + void OSystem_GP32::load_gfx_mode() { - GpRectFill(NULL,&gpDraw[GAME_SURFACE], 0, 0, 320, 240, 0); //black border + GpRectFill(NULL, &LCDbuffer[GAME_SURFACE], 0, 0, 320, 240, 0); //black border _forceFull = true; _mode_flags = DF_WANT_RECT_OPTIM | DF_UPDATE_EXPAND_1_PIXEL; - sdl_tmpscreen = NULL; + _tmpscreen = NULL; TMP_SCREEN_WIDTH = (_screenWidth + 3); - - switch(_mode) { + + switch (_mode) { case GFX_NORMAL: -normal_mode:; + //??????? + //normal_mode:; _scaleFactor = 1; _scaler_proc = Normal1x; + break; default: - error("unknown gfx mode"); + error("Unknown graphics mode"); _scaleFactor = 1; _scaler_proc = NULL; } @@ -376,159 +670,168 @@ normal_mode:; // // Create the surface that contains the 8 bit game data // - _screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _screenWidth, _screenHeight, 8, 0, 0, 0, 0); + _screen = + gpCreateRGBSurface(gpSWSurface, _screenWidth, _screenHeight, 8, 0, + 0, 0, 0); if (_screen == NULL) error("_screen failed"); - // // Create the surface that contains the scaled graphics in 16 bit mode // - sdl_hwscreen = SDL_SetVideoMode(_screenWidth * _scaleFactor, _screenHeight * _scaleFactor, 16, - _full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE - ); - if (sdl_hwscreen == NULL) - error("sdl_hwscreen failed"); - + _hwscreen = + gpSetVideoMode(_screenWidth * _scaleFactor, + _screenHeight * _scaleFactor, 16, + _full_screen ? (gpFullScreen | gpSWSurface) : gpSWSurface); + if (_hwscreen == NULL) + error("_hwscreen failed"); + // // Create the surface used for the graphics in 16 bit before scaling, and also the overlay // /* // Distinguish 555 and 565 mode - if (sdl_hwscreen->format->Rmask == 0x7C00) + if (_hwscreen->format->Rmask == 0x7C00) InitScalers(555); else InitScalers(565); */ //InitScalers(555); // ph0x fixme? - //ph0x fixme - tmpscreen needed? + //ph0x fixme - tmpscreen needed? + // Need some extra bytes around when using 2xSaI - uint16 *tmp_screen = (uint16*)calloc(TMP_SCREEN_WIDTH*(_screenHeight+3),sizeof(uint16)); - sdl_tmpscreen = SDL_CreateRGBSurfaceFrom(tmp_screen, - TMP_SCREEN_WIDTH, _screenHeight + 3, 16, TMP_SCREEN_WIDTH*2, - sdl_hwscreen->format->Rmask, - sdl_hwscreen->format->Gmask, - sdl_hwscreen->format->Bmask, - sdl_hwscreen->format->Amask); - - if (sdl_tmpscreen == NULL) - error("sdl_tmpscreen failed"); - - + uint16 *tmp_screen = + (uint16 *) calloc(TMP_SCREEN_WIDTH * (_screenHeight + 3), + sizeof(uint16)); + _tmpscreen = + gpCreateRGBSurfaceFrom(tmp_screen, TMP_SCREEN_WIDTH, + _screenHeight + 3, 16, TMP_SCREEN_WIDTH * 2, + _hwscreen->format->Rmask, _hwscreen->format->Gmask, + _hwscreen->format->Bmask, _hwscreen->format->Amask); + + if (_tmpscreen == NULL) + error("_tmpscreen failed"); + // keyboard cursor control, some other better place for it? km.x_max = _screenWidth * _scaleFactor - 1; km.y_max = _screenHeight * _scaleFactor - 1; - km.delay_time = 25; + //km.delay_time = 25; + km.delay_time = 15; km.last_time = 0; } void OSystem_GP32::unload_gfx_mode() { if (_screen) { - SDL_FreeSurface(_screen); - _screen = NULL; + gpFreeSurface(_screen); + _screen = NULL; } - if (sdl_hwscreen) { - SDL_FreeSurface(sdl_hwscreen); - sdl_hwscreen = NULL; + if (_hwscreen) { + gpFreeSurface(_hwscreen); + _hwscreen = NULL; } - - if (sdl_tmpscreen) { - free((uint16*)sdl_tmpscreen->pixels); - SDL_FreeSurface(sdl_tmpscreen); - sdl_tmpscreen = NULL; + + if (_tmpscreen) { + free((uint16 *) _tmpscreen->pixels); + gpFreeSurface(_tmpscreen); + _tmpscreen = NULL; } } - #include "common/util.h" + void OSystem_GP32::draw_mouse() { - if (!_overlay_visible) { + if (!_overlayVisible) { - if (_mouseDrawn || !_mouseVisible) - return; + if (_mouseDrawn || !_mouseVisible) + return; - int x = _mouse_cur_state.x - _mouseHotspotX; - int y = _mouse_cur_state.y - _mouseHotspotY; - int w = _mouse_cur_state.w; - int h = _mouse_cur_state.h; - byte color; - byte *src = _mouseData; // Image representing the mouse - byte *bak = _mouseBackup; // Surface used to backup the area obscured by the mouse - byte *dst; // Surface we are drawing into + int x = _mouseCurState.x - _mouseHotspotX; + int y = _mouseCurState.y - _mouseHotspotY; + int w = _mouseCurState.w; + int h = _mouseCurState.h; + byte color; + byte *src = _mouseData; // Image representing the mouse + byte *bak = _mouseBackup; // Surface used to backup the area obscured by the mouse + byte *dst; // Surface we are drawing into + + // clip the mouse rect, and addjust the src pointer accordingly + if (x < 0) { + w += x; + src -= x; + x = 0; + } + if (y < 0) { + h += y; + src -= y * _mouseCurState.w; + y = 0; + } + if (w > _screenWidth - x) + w = _screenWidth - x; + if (h > _screenHeight - y) + h = _screenHeight - y; - // clip the mouse rect, and addjust the src pointer accordingly - if (x < 0) { - w += x; - src -= x; - x = 0; - } - if (y < 0) { - h += y; - src -= y * _mouse_cur_state.w; - y = 0; - } - if (w > _screenWidth - x) - w = _screenWidth - x; - if (h > _screenHeight - y) - h = _screenHeight - y; + // Quick check to see if anything has to be drawn at all + if (w <= 0 || h <= 0) + return; - // Quick check to see if anything has to be drawn at all - if (w <= 0 || h <= 0) - return; + // Store the bounding box so that undraw mouse can restore the area the + // mouse currently covers to its original content. + _mouseOldState.x = x; + _mouseOldState.y = y; + _mouseOldState.w = w; + _mouseOldState.h = h; - // Store the bounding box so that undraw mouse can restore the area the - // mouse currently covers to its original content. - _mouse_old_state.x = x; - _mouse_old_state.y = y; - _mouse_old_state.w = w; - _mouse_old_state.h = h; + // Draw the mouse cursor; backup the covered area in "bak" - // Draw the mouse cursor; backup the covered area in "bak" + ///if (gpLockSurface(_screen) == -1) + /// error("gpLockSurface failed: %s.\n", gpGetError()); - ///if (SDL_LockSurface(_screen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); - - // Mark as dirty - add_dirty_rect(x, y, w, h); + // as dirty + add_dirty_rect(x, y, w, h); - dst = (byte *)_screen->pixels + y * _screenWidth + x; - while (h > 0) { - int width = w; - while (width > 0) { - *bak++ = *dst; - color = *src++; - if (color != _mouseKeycolor) // transparent, don't draw - *dst = color; - dst++; - width--; + dst = (byte *) _screen->pixels + y * _screenWidth + x; + while (h > 0) { + int width = w; + while (width > 0) { + *bak++ = *dst; + color = *src++; + if (color != _mouseKeycolor) // Transparent, don't draw + *dst = color; + dst++; + width--; + } + src += _mouseCurState.w - w; + bak += MAX_MOUSE_W - w; + dst += _screenWidth - w; + h--; } - src += _mouse_cur_state.w - w; - bak += MAX_MOUSE_W - w; - dst += _screenWidth - w; - h--; - } - ///SDL_UnlockSurface(_screen); + ///gpUnlockSurface(_screen); - // Finally, set the flag to indicate the mouse has been drawn - _mouseDrawn = true; + // Finally, set the flag to indicate the mouse has been drawn + _mouseDrawn = true; } if (_mouseDrawn || !_mouseVisible) return; - int x = _mouse_cur_state.x - _mouseHotspotX; - int y = _mouse_cur_state.y - _mouseHotspotY; - int w = _mouse_cur_state.w; - int h = _mouse_cur_state.h; + int x = _mouseCurState.x - _mouseHotspotX; + int y = _mouseCurState.y - _mouseHotspotY; + int w = _mouseCurState.w; + int h = _mouseCurState.h; byte color; - byte *src = _mouseData; // Image representing the mouse - uint16 *bak = (uint16*)_mouseBackup; // Surface used to backup the area obscured by the mouse - uint16 *dst; // Surface we are drawing into + //byte *src = _mouseData; // Image representing the mouse + //uint16 *src = _mouseData; // Image representing the mouse + const byte *src = _mouseData; // Image representing the mouse + //byte *bak = _mouseBackup; // Surface used to backup the area obscured by the mouse + //byte *dst; // Surface we are drawing into + + //uint16 *bak = (uint16*)_mouseBackup; // Surface used to backup the area obscured by the mouse + //uint16 *dst; // Surface we are drawing into // clip the mouse rect, and addjust the src pointer accordingly if (x < 0) { @@ -538,10 +841,9 @@ void OSystem_GP32::draw_mouse() { } if (y < 0) { h += y; - src -= y * _mouse_cur_state.w; + src -= y * _mouseCurState.w; y = 0; } - // Quick check to see if anything has to be drawn at all if (w <= 0 || h <= 0) return; @@ -553,218 +855,234 @@ void OSystem_GP32::draw_mouse() { // Store the bounding box so that undraw mouse can restore the area the // mouse currently covers to its original content. - _mouse_old_state.x = x; - _mouse_old_state.y = y; - _mouse_old_state.w = w; - _mouse_old_state.h = h; + _mouseOldState.x = x; + _mouseOldState.y = y; + _mouseOldState.w = w; + _mouseOldState.h = h; // Draw the mouse cursor; backup the covered area in "bak" - ///if (SDL_LockSurface(sdl_tmpscreen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); + ///if (gpLockSurface(_tmpscreen) == -1) + /// error("gpLockSurface failed: %s.\n", gpGetError()); - // Mark as dirty + // as dirty add_dirty_rect(x, y, w, h); - dst = (uint16 *)sdl_tmpscreen->pixels + (y+1) * TMP_SCREEN_WIDTH + (x+1); + uint16 *bak = (uint16 *) _mouseBackup; // Surface used to backup the area obscured by the mouse + uint16 *dst; // Surface we are drawing into + + dst = + (uint16 *) _tmpscreen->pixels + (y + 1) * TMP_SCREEN_WIDTH + (x + + 1); while (h > 0) { int width = w; while (width > 0) { *bak++ = *dst; color = *src++; if (color != 0xFF) // 0xFF = transparent, don't draw - *dst = RGBToColor(_currentPalette[color].r, _currentPalette[color].g, _currentPalette[color].b); + *dst = + RGB_TO_16(_currentPalette[color].r, + _currentPalette[color].g, + _currentPalette[color].b); dst++; width--; } - src += _mouse_cur_state.w - w; + src += _mouseCurState.w - w; bak += MAX_MOUSE_W - w; dst += TMP_SCREEN_WIDTH - w; h--; } - ///SDL_UnlockSurface(sdl_tmpscreen); - + ///gpUnlockSurface(_tmpscreen); + // Finally, set the flag to indicate the mouse has been drawn - _mouseDrawn = true; + _mouseDrawn = true; } -void OSystem_GP32::undraw_mouse() { //return; //fixme! - if (!_overlay_visible) { - - if (!_mouseDrawn) - return; - _mouseDrawn = false; - - ///if (SDL_LockSurface(_screen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); +void OSystem_GP32::undraw_mouse() { + //return; //fixme! + if (!_overlayVisible) { - byte *dst, *bak = _mouseBackup; - const int old_mouse_x = _mouse_old_state.x; - const int old_mouse_y = _mouse_old_state.y; - const int old_mouse_w = _mouse_old_state.w; - const int old_mouse_h = _mouse_old_state.h; - int x, y; - - // No need to do clipping here, since draw_mouse() did that already - - dst = (byte *)_screen->pixels + old_mouse_y * _screenWidth + old_mouse_x; - for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _screenWidth) { - for (x = 0; x < old_mouse_w; ++x) { - dst[x] = bak[x]; + if (!_mouseDrawn) + return; + _mouseDrawn = false; + + byte *dst, *bak = _mouseBackup; + const int old_mouse_x = _mouseOldState.x; + const int old_mouse_y = _mouseOldState.y; + const int old_mouse_w = _mouseOldState.w; + const int old_mouse_h = _mouseOldState.h; + int x, y; + + // No need to do clipping here, since draw_mouse() did that already + + dst = + (byte *) _screen->pixels + old_mouse_y * _screenWidth + + old_mouse_x; + for (y = 0; y < old_mouse_h; + ++y, bak += MAX_MOUSE_W, dst += _screenWidth) { + for (x = 0; x < old_mouse_w; ++x) { + dst[x] = bak[x]; + } } - } - - add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h); - ///SDL_UnlockSurface(_screen); + add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, + old_mouse_h); } if (!_mouseDrawn) return; _mouseDrawn = false; - ///if (SDL_LockSurface(sdl_tmpscreen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); - - uint16 *dst, *bak = (uint16 *)_mouseBackup; - const int old_mouse_x = _mouse_old_state.x; - const int old_mouse_y = _mouse_old_state.y; - const int old_mouse_w = _mouse_old_state.w; - const int old_mouse_h = _mouse_old_state.h; + uint16 *dst, *bak = (uint16 *) _mouseBackup; + const int old_mouse_x = _mouseOldState.x; + const int old_mouse_y = _mouseOldState.y; + const int old_mouse_w = _mouseOldState.w; + const int old_mouse_h = _mouseOldState.h; int x, y; // No need to do clipping here, since draw_mouse() did that already - dst = (uint16 *)sdl_tmpscreen->pixels + (old_mouse_y+1) * TMP_SCREEN_WIDTH + (old_mouse_x+1); - for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += TMP_SCREEN_WIDTH) { + dst = + (uint16 *) _tmpscreen->pixels + (old_mouse_y + + 1) * TMP_SCREEN_WIDTH + (old_mouse_x + 1); + for (y = 0; y < old_mouse_h; + ++y, bak += MAX_MOUSE_W, dst += TMP_SCREEN_WIDTH) { for (x = 0; x < old_mouse_w; ++x) { dst[x] = bak[x]; } } add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h); - - ///SDL_UnlockSurface(sdl_tmpscreen); } -char * SDL_GetError() { - - // implement +char *gpGetError(void) { + // FIXME: implement return NULL; } -// Update the dirty areas of the screen -void OSystem_GP32::updateScreen() { - assert(sdl_hwscreen != NULL); - - // If the shake position changed, fill the dirty area with blackness - if (_currentShakePos != _newShakePos) { - SDL_Rect blackrect = {0, 0, _screenWidth*_scaleFactor, _newShakePos*_scaleFactor}; - SDL_FillRect(sdl_hwscreen, &blackrect, 0); - - _currentShakePos = _newShakePos; - - _forceFull = true; - } - - // Make sure the mouse is drawn, if it should be drawn. - draw_mouse(); //ph0x - - // Check whether the palette was changed in the meantime and update the - // screen surface accordingly. - if (_paletteDirtyEnd != 0) { - SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart, - _paletteDirtyStart, - _paletteDirtyEnd - _paletteDirtyStart); - - _paletteDirtyEnd = 0; - - _forceFull = true; - } - - // Force a full redraw if requested - if (_forceFull) { - _num_dirty_rects = 1; - - _dirty_rect_list[0].x = 0; - _dirty_rect_list[0].y = 0; - _dirty_rect_list[0].w = _screenWidth; - _dirty_rect_list[0].h = _screenHeight; - } - - // Only draw anything if necessary - if (_num_dirty_rects > 0) { - - SDL_Rect *r; - uint32 srcPitch, dstPitch; - SDL_Rect *last_rect = _dirty_rect_list + _num_dirty_rects; - - // Convert appropriate parts of the 8bpp image into 16bpp - if (!_overlay_visible) { - SDL_Rect dst; - for(r = _dirty_rect_list; r != last_rect; ++r) { - dst = *r; - dst.x++; // FIXME? Shift rect by one since 2xSai needs to acces the data around - dst.y++; // FIXME? any pixel to scale it, and we want to avoid mem access crashes. - if (SDL_BlitSurface(_screen, r, sdl_hwscreen, &dst) != 0) //ph0x! sdl_tmpscreen - error("SDL_BlitSurface failed: %s", SDL_GetError()); - } - } - - ///SDL_LockSurface(sdl_tmpscreen); - ///SDL_LockSurface(sdl_hwscreen); - -// ph0x! (no scaling) cannot skip intro if commented? - - srcPitch = sdl_tmpscreen->pitch; - dstPitch = sdl_hwscreen->pitch; - for(r = _dirty_rect_list; r != last_rect; ++r) { - register int dst_y = r->y + _currentShakePos; - register int dst_h = 0; - if (dst_y < _screenHeight) { - dst_h = r->h; - if (dst_h > _screenHeight - dst_y) - dst_h = _screenHeight - dst_y; - - dst_y *= _scaleFactor; - - _scaler_proc((byte*)sdl_tmpscreen->pixels + (r->x*2+2) + (r->y+1)*srcPitch, srcPitch, (byte*)sdl_hwscreen->pixels + r->x*2*_scaleFactor + dst_y*dstPitch, dstPitch, r->w, dst_h); - } - r->x *= _scaleFactor; - r->y = dst_y; - r->w *= _scaleFactor; - r->h = dst_h * _scaleFactor; - } - - ///SDL_UnlockSurface(sdl_tmpscreen); - ///SDL_UnlockSurface(sdl_hwscreen); - - // Readjust the dirty rect list in case we are doing a full update. - // This is necessary if shaking is active. - if (_forceFull) { - _dirty_rect_list[0].y = 0; - _dirty_rect_list[0].h = _screenHeight * _scaleFactor; - } - - // Finally, blit all our changes to the screen - - // FIXME (dont use condition) - if (_overlay_visible) - SDL_UpdateRects(sdl_hwscreen, _num_dirty_rects, _dirty_rect_list); //ph0x! sdl_hwscreen - else - SDL_UpdateRects(_screen, _num_dirty_rects, _dirty_rect_list); - } - - _num_dirty_rects = 0; - _forceFull = false; -} +///////////////////////////////////////////////////////////////////////////// +// +// GP32 Screen Update Stuff - Mostly 'borrowed' from GP but using gpSDK +// +///////////////////////////////////////////////////////////////////////////// + +//// Update the dirty areas of the screen +void OSystem_GP32::updateScreen() { + //Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends + internUpdateScreen(); +} + +// assert(_hwscreen != NULL); +// +// // If the shake position changed, fill the dirty area with blackness +// if (_currentShakePos != _newShakePos) { +// gpRect blackrect = {0, 0, _screenWidth*_scaleFactor, _newShakePos*_scaleFactor}; +// +// if (_adjustAspectRatio) +// blackrect.h = real2Aspect(blackrect.h - 1) + 1; +// +// gpFillRect(_hwscreen, &blackrect, 0); +// +// _currentShakePos = _newShakePos; +// +// _forceFull = true; +// } +// +// // Make sure the mouse is drawn, if it should be drawn. +// draw_mouse(); +// +// // Check whether the palette was changed in the meantime and update the +// // screen surface accordingly. +// if (_paletteDirtyEnd != 0) { +// gpSetColors(_screen, _currentPalette + _paletteDirtyStart, +// _paletteDirtyStart, +// _paletteDirtyEnd - _paletteDirtyStart); +// +// _paletteDirtyEnd = 0; +// +// _forceFull = true; +// } +// +// // Force a full redraw if requested +// if (_forceFull) { +// _num_dirty_rects = 1; +// +// _dirty_rect_list[0].x = 0; +// _dirty_rect_list[0].y = 0; +// _dirty_rect_list[0].w = _screenWidth; +// _dirty_rect_list[0].h = _screenHeight; +// } +// +// // Only draw anything if necessary +// if (_num_dirty_rects > 0) { +// +// gpRect *r; +// uint32 srcPitch, dstPitch; +// gpRect *last_rect = _dirty_rect_list + _num_dirty_rects; +// +// // Convert appropriate parts of the 8bpp image into 16bpp +// if (!_overlayVisible) { +// gpRect dst; +// for(r = _dirty_rect_list; r != last_rect; ++r) { +// dst = *r; +// dst.x++; // FIXME? Shift rect by one since 2xSai needs to acces the data around +// dst.y++; // FIXME? any pixel to scale it, and we want to avoid mem access crashes. +// +// if (gpBlitSurface(_screen, r, _hwscreen, &dst) != 0) //ph0x! _tmpscreen +// error("gpBlitSurface failed: %s", gpGetError()); +// } +// } +// +//// ph0x! (no scaling) cannot skip intro if commented? +// +// srcPitch = _tmpscreen->pitch; +// dstPitch = _hwscreen->pitch; +// for(r = _dirty_rect_list; r != last_rect; ++r) { +// register int dst_y = r->y + _currentShakePos; +// register int dst_h = 0; +// if (dst_y < _screenHeight) { +// dst_h = r->h; +// if (dst_h > _screenHeight - dst_y) +// dst_h = _screenHeight - dst_y; +// +// dst_y *= _scaleFactor; +// +// if (_overlayVisible) //ph0x fixme? +// _scaler_proc((byte*)_tmpscreen->pixels + (r->x*2+2) + (r->y+1)*srcPitch, srcPitch, +// (byte*)_hwscreen->pixels + r->x*2*_scaleFactor + dst_y*dstPitch, dstPitch, r->w, dst_h); +// } +// r->x *= _scaleFactor; +// r->y = dst_y; +// r->w *= _scaleFactor; +// r->h = dst_h * _scaleFactor; +// } +// +// // Readjust the dirty rect list in case we are doing a full update. +// // This is necessary if shaking is active. +// if (_forceFull) { +// _dirty_rect_list[0].y = 0; +// _dirty_rect_list[0].h = _screenHeight * _scaleFactor; +// } +// +// // Finally, blit all our changes to the screen +// +// // FIXME (dont use condition) +// if (_overlayVisible) +// gpUpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list); //ph0x! _hwscreen +// else +// gpUpdateRects(_screen, _num_dirty_rects, _dirty_rect_list); +// } +// +// _num_dirty_rects = 0; +// _forceFull = false; +//} // Either show or hide the mouse cursor -bool OSystem_GP32::showMouse(bool visible) { +bool OSystem_GP32::showMouse(bool visible) { if (_mouseVisible == visible) return visible; - + bool last = _mouseVisible; _mouseVisible = visible; @@ -775,195 +1093,562 @@ bool OSystem_GP32::showMouse(bool visible) { return last; } - + // Set the position of the mouse cursor -void OSystem_GP32::set_mouse_pos(int x, int y) { - if (x != _mouse_cur_state.x || y != _mouse_cur_state.y) { - _mouse_cur_state.x = x; - _mouse_cur_state.y = y; +void OSystem_GP32::set_mouse_pos(int x, int y) { + if (x != _mouseCurState.x || y != _mouseCurState.y) { + _mouseCurState.x = x; + _mouseCurState.y = y; - mx=x; //ph0x fixme - my=y; //ph0x fixme + mx = x; //ph0x fixme + my = y; //ph0x fixme undraw_mouse(); } } -void OSystem_GP32::warpMouse(int x, int y) { - set_mouse_pos(x, y); -} - // Set the bitmap that's used when drawing the cursor. -void OSystem_GP32::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor) { - _mouse_cur_state.w = w; - _mouse_cur_state.h = h; +void OSystem_GP32::setMouseCursor(const byte *buf, uint w, uint h, + int hotspot_x, int hotspot_y, byte keycolor, int cursorTargetScale) { + +// assert(w <= MAX_MOUSE_W); +// assert(h <= MAX_MOUSE_H); + + _mouseCurState.w = w; + _mouseCurState.h = h; _mouseHotspotX = hotspot_x; _mouseHotspotY = hotspot_y; _mouseKeycolor = keycolor; +//?????????? + _mouseData = (byte *) buf; + + undraw_mouse(); + if (_mouseData) free(_mouseData); - _mouseData = (byte *)malloc(w * h); - memcpy(_mouseData, buf, w * h); + _mouseData = (byte *) malloc(w * h); - undraw_mouse(); + memcpy(_mouseData, buf, w * h); } - + // Shaking is used in SCUMM. Set current shake position. -void OSystem_GP32::setShakePos(int shake_pos) { +void OSystem_GP32::setShakePos(int shake_pos) { _newShakePos = shake_pos; + mcshake = shake_pos; } - + // Get the number of milliseconds since the program was started. -uint32 OSystem_GP32::getMillis() { - return GpTickCountGet(); +uint32 OSystem_GP32::getMillis() { + return GpTickCountGet(); } - + // Delay for a specified amount of milliseconds -void OSystem_GP32::delayMillis(uint msecs) { +void OSystem_GP32::delayMillis(uint msecs) { int n = GpTickCountGet(); - while ( ( GpTickCountGet() - n ) < msecs) ; + while ((GpTickCountGet() - n) < msecs); } - + // Get the next event. -// Returns true if an event was retrieved. +// Returns true if an event was retrieved. + +const signed char abc[] = "0123456789abcdefghijklmnopqrstuvwxyz"; +signed int abcindex = -1; + +void switchsurf(int surf); +void buildgammatab(int val); + +///////////////////////////////////////////////////////////////////////////// +// +// GP32 Event Handlers. +// +///////////////////////////////////////////////////////////////////////////// + +bool OSystem_GP32::pollEvent(Event & event) { -bool OSystem_GP32::pollEvent(Event &event) { // fixme: make more user-friendly :) +#define EVENT_COUNT 2 // >=1 + //#define MOUSE_MIPS 2 // bg updates wrong if >1 ?? +#define MOUSE_MIPS 1 // bg updates wrong if >1 ?? - #define EVENT_COUNT 2 // >=1 - #define MOUSE_MIPS 1 // bg updates wrong if >1 ?? - - static int oldkey, eventcount=EVENT_COUNT, lastevent=0; - int key; + static int lastkey, eventcount = EVENT_COUNT, lastevent = 0; + static int simulate; + static bool backspace = true; + static uint32 t; + int key; + + key = gpTrapKey(); + + if (simulate) + simulate--; + switch (simulate) { + case 5: + lastevent = event.type = EVENT_KEYDOWN; + event.kbd.keycode = event.kbd.ascii = 8; + return true; + break; + case 3: + lastevent = event.type = EVENT_KEYDOWN; + event.kbd.keycode = event.kbd.ascii = abc[abcindex]; + return true; + break; + case 4: + case 2: + lastevent = event.type = EVENT_KEYUP; + //event.kbd.keycode = event.kbd.ascii = + return true; + break; + case 1: + lastkey = key = 0; + lastevent = 0; + event.type = (EventType) 0; + break; + } + + if (lastevent == EVENT_KEYDOWN) { + lastevent = event.type = EVENT_KEYUP; + //event.kbd.keycode = event.kbd.ascii; + return true; + } - key=GpKeyGet(); if (key == GPC_VK_NONE) { - if (lastevent==EVENT_LBUTTONDOWN) { - lastevent=0; - event.type = EVENT_LBUTTONUP; - return true; - } + lastevent = lastkey = 0; return false; - } + } - if (key == oldkey) { + if (key == lastkey) { eventcount--; - if (eventcount) return false; + if (eventcount) + return false; } - oldkey=key; - eventcount=EVENT_COUNT; + eventcount = EVENT_COUNT; event.type = EVENT_KEYDOWN; - if (key & GPC_VK_FL && key & GPC_VK_FR) { // L+R = save state - printf("Saving game, please wait..."); + if (key & GPC_VK_FL) { // L + if (_overlayVisible) + return false; + + if (key & GPC_VK_UP) { + if (key == lastkey) + return false; + + if (gindex < ARRAYSIZE(scrGamma) - 1) + gindex++; + buildgammatab(gindex); + _paletteDirtyStart = 0; + _paletteDirtyEnd = 255; //fixme? + lastevent = event.type; + lastkey = key; + return true; + } else + if (key & GPC_VK_DOWN) { + if (key == lastkey) + return false; + + if (gindex > 0) + gindex--; + buildgammatab(gindex); + _paletteDirtyStart = 0; + _paletteDirtyEnd = 255; //fixme? + lastevent = event.type; + lastkey = key; + return true; + } - //extern void autosave(void * engine); - //autosave(NULL); //FIXME? - do key=GpKeyGet(); while (key != GPC_VK_NONE) ; - return false; - } - - if (key & GPC_VK_FL) { // L = debug console - //GpGraphicModeSet(8, NULL); //FIXME: if 16bit? - currsurface=DEBUG_SURFACE; - GpSurfaceFlip(&gpDraw[currsurface]); - GpSetPaletteEntry ( 0, 0,0,0 ); - GpSetPaletteEntry ( 1, 255,0,0 ); - GpSetPaletteEntry ( 2, 255,255,255 ); - return false; + if (key == lastkey) + return false; + if (skindex > 0) + skindex--; + event.kbd.keycode = event.kbd.ascii = shortkey[skindex]; + lastevent = event.type; + lastkey = key; + return true; } - - if (key & GPC_VK_FR) { // R = game screen - //if (_overlay_visible) GpGraphicModeSet(16, NULL); - // else GpGraphicModeSet(8, NULL); - currsurface=GAME_SURFACE; - GpSurfaceFlip(&gpDraw[currsurface]); - _paletteDirtyStart=0; - _paletteDirtyEnd=255; //fixme? - return false; - } + lastkey = key; + + if (key & GPC_VK_FR) { // R + if (key & GPC_VK_UP) { + if (getMillis() < t) + return false; + //do key=GpKeyGet(); while (key & GPC_VK_UP); + //fixme -2/-1 + t = getMillis() + 200; + if (abcindex == -1) + abcindex = 0; + else { + if (abcindex < sizeof(abc) - 2) + abcindex++; + else + abcindex = 0; + } + if (backspace) + simulate = 6; + else { + backspace = true; + simulate = 4; + } + return false; + } + + if (key & GPC_VK_DOWN) { + if (getMillis() < t) + return false; + //do key=GpKeyGet(); while (key & GPC_VK_DOWN); + //fixme -2/-1 + t = getMillis() + 200; + if (abcindex == -1) + abcindex = abcindex = sizeof(abc) - 2; + else { + if (abcindex > 0) + abcindex--; + else + abcindex = sizeof(abc) - 2; + } + if (backspace) + simulate = 6; + else { + backspace = true; + simulate = 4; + } + return false; + } - if (key & GPC_VK_START) { // START = menu - event.kbd.keycode = 319; - event.kbd.ascii = 319; - return true; + if (key & GPC_VK_LEFT) { + abcindex = -1; + event.kbd.keycode = event.kbd.ascii = 8; + lastevent = event.type; + do + key = gpTrapKey(); + while (key & GPC_VK_LEFT); + return true; + } else if (key & GPC_VK_RIGHT) { + abcindex = -1; + backspace = false; + return false; + } + if (!_overlayVisible) { + if (lastevent == EVENT_KEYUP) + return false; + if (shortkey[skindex + 1]) + skindex++; + event.kbd.keycode = event.kbd.ascii = + shortkey[skindex]; + lastevent = event.type; + return true; + } + } else if (key & GPC_VK_START) { // START = menu/enter + if (_overlayVisible) + event.kbd.keycode = event.kbd.ascii = 13; + else { + event.kbd.keycode = event.kbd.ascii = 319; + //buildgammatab(ARRAYSIZE(scrGamma)-1); // moved to colortoRBG + } + lastevent = event.type; + return true; } - if (key & GPC_VK_SELECT) { // SELECT == escape/skip - if (_overlay_visible) - do key=GpKeyGet(); while (key != GPC_VK_NONE) ; // prevent 2xESC - event.kbd.keycode = 27; - event.kbd.ascii = 27; + if (key & GPC_VK_SELECT) { // SELECT == escape/skip + if (_overlayVisible) { + do + key = gpTrapKey(); + while (key != GPC_VK_NONE); // prevent 2xESC + buildgammatab(gindex); + _paletteDirtyStart = 0; + _paletteDirtyEnd = 255; //fixme? + } + event.kbd.keycode = event.kbd.ascii = 27; + lastevent = event.type; return true; - } + } if (key & GPC_VK_FA) { - lastevent=EVENT_LBUTTONDOWN; - event.type = EVENT_LBUTTONDOWN; + if (lastevent == EVENT_LBUTTONUP) + return false; + + if (lastevent == EVENT_LBUTTONDOWN) { + lastevent = EVENT_LBUTTONUP; + event.type = EVENT_LBUTTONUP; + } else { + lastevent = EVENT_LBUTTONDOWN; + event.type = EVENT_LBUTTONDOWN; + } return true; } + if (key & GPC_VK_FB) { - lastevent=EVENT_RBUTTONDOWN; - event.type = EVENT_RBUTTONDOWN; + if (lastevent == EVENT_RBUTTONUP) + return false; + + if (lastevent == EVENT_RBUTTONDOWN) { + lastevent = EVENT_RBUTTONUP; + event.type = EVENT_RBUTTONUP; + } else { + lastevent = EVENT_RBUTTONDOWN; + event.type = EVENT_RBUTTONDOWN; + } return true; } - if(key & GPC_VK_LEFT) { - mx-=MOUSE_MIPS; - if (mx<1) mx=1; // wrong if 0? + if (key & GPC_VK_LEFT) { + mx -= MOUSE_MIPS; + if (mx < 1) + mx = 1; // wrong if 0? } - if(key & GPC_VK_RIGHT) { - mx+=MOUSE_MIPS; - if (mx>319) mx=319; + if (key & GPC_VK_RIGHT) { + mx += MOUSE_MIPS; + if (mx > 319) + mx = 319; } - if(key & GPC_VK_UP) { - my-=MOUSE_MIPS; - if (my<1) my=1; // wrong if 0? + if (key & GPC_VK_UP) { + my -= MOUSE_MIPS; + if (my < 1) + my = 1; // wrong if 0? } - if(key & GPC_VK_DOWN) { - my+=MOUSE_MIPS; - if (my>199) my=199; + if (key & GPC_VK_DOWN) { + my += MOUSE_MIPS; + if (my > _screenHeight - 1) + my = _screenHeight - 1; } event.type = EVENT_MOUSEMOVE; km.x = event.mouse.x = mx; km.y = event.mouse.y = my; - event.mouse.x /= _scaleFactor; - event.mouse.y /= _scaleFactor; - + event.mouse.y /= _scaleFactor; set_mouse_pos(event.mouse.x, event.mouse.y); } -// Set the function to be invoked whenever samples need to be generated -// Format is the sample type format. -// Only 16-bit signed mode is needed for simon & scumm -bool OSystem_GP32::setSoundCallback(SoundProc proc, void *param) { - return false; +///////////////////////////////////////////////////////////////////////////// +// +// GP32 Graphics Stuff - +// +///////////////////////////////////////////////////////////////////////////// + +int16 OSystem_GP32::RBGToColor(uint8 r, uint8 g, uint8 b) { + float rr, gg, bb; + + rr = r * gammatab2[r]; + gg = g * gammatab2[g]; + bb = b * gammatab2[b]; + + if (rr > 255) + rr = 255; + if (gg > 255) + gg = 255; + if (bb > 255) + bb = 255; + + r = (u8) rr; + g = (u8) gg; + b = (u8) bb; + + //return ((((r>>3)&0x1F) << 11) | (((g>>2)&0x3F) << 5) | ((b>>3)&0x1F)); //ph0x + return (((((r) >> 3) & 0x1F) << 11) | ((((g) >> 3) & 0x1F) << 6) | + (((b) >> 3) & 0x1F) << 1); } +void OSystem_GP32::colorToRBG(int16 color, uint8 &r, uint8 &g, uint8 &b) { + float rr, gg, bb; + r = ((((color) >> 11) & 0x1F) << 3); //(((color>>11)&0x1F) << 3); + g = ((((color) >> 6) & 0x1F) << 3); //(((color>>5)&0x3F) << 2); + b = ((((color) >> 1) & 0x1F) << 3); //((color&0x1F) << 3); + + rr = r * gammatab2[r]; + gg = g * gammatab2[g]; + bb = b * gammatab2[b]; + + if (rr > 255) + rr = 255; + if (gg > 255) + gg = 255; + if (bb > 255) + bb = 255; + + r = (u8) rr; + g = (u8) gg; + b = (u8) bb; +} + +void switchsurf(int surf) { + GPLCDINFO lcd; + GpLcdInfoGet(&lcd); + + if (surf == DEBUG_SURFACE) { + if (lcd.lcd_global.U8_lcd.bpp == 16) + GpGraphicModeSet(8, NULL); + + currentsurf = DEBUG_SURFACE; + GpSurfaceFlip(&LCDbuffer[(int)currentsurf]); + + //GpSetPaletteEntry ( 0, 0,0,0 ); + //GpSetPaletteEntry ( 1, 0,0,0 ); + //GpSetPaletteEntry ( 2, 255,255,255 ); + + } else if (surf == GAME_SURFACE) { + //if (lcd.lcd_global.U8_lcd.bpp == 8) GpGraphicModeSet(16, NULL); + + currentsurf = GAME_SURFACE; + GpSurfaceFlip(&LCDbuffer[(int)currentsurf]); + //GpSetPaletteEntry ( 2, 0,0,0 ); + //GpSetPaletteEntry ( 1, 0,107,84 ); + //GpSetPaletteEntry ( 0, 255,255,255 ); + } else + error("Switching to false stuface"); +} + +///////////////////////////////////////////////////////////////////////////// +// +// GP32 Sound Stuff - +// +///////////////////////////////////////////////////////////////////////////// + void OSystem_GP32::clearSoundCallback() { - //_sound_proc = NULL; - //_sound_proc_param = NULL; +// _sound_proc = NULL; +// _sound_proc_param = NULL; +} + +typedef void SoundProc(void *param, byte *buf, int len); + +typedef struct GPSOUNDBUF { + PCM_SR freq; /* Taken from gpmm.h */ + PCM_BIT format; /* Taken from gpmm.h */ + unsigned int samples; /* Buffer length (in samples) */ + void *userdata; /* Userdata which gets passed to the callback function */ + SoundProc *callback; + unsigned int pollfreq; /* Frequency of the timer interrupt which polls the playing position + * recommended value: 2*(playingfreq in Hz/GPSOUNDBUF.samples) */ + unsigned int samplesize; /* Size of one sample (8bit mono->1, 16bit stereo->4) - don't touch this */ +} GPSOUNDBUF; + +GPSOUNDBUF gpsndbuf; // for scumm + +/* Global variables */ +unsigned int frame = 0; +unsigned int *soundPos = 0; +volatile int idx_buf; +unsigned int shiftVal = 0; +void *buffer; +GPSOUNDBUF soundBuf; + +/* This routine gets called by the timer interrupt and + * polls the current playing position within the buffer. + */ + +//void *blah; // holds "this" for mixer.cpp + +void soundtimer(void) { + unsigned int t = + (((unsigned int)(*soundPos) - (unsigned int)buffer) >> shiftVal) >= + soundBuf.samples ? 1 : 0; + if (t != frame) { + unsigned int offs = + ((frame == 1) ? (soundBuf.samples << shiftVal) : 0); + soundBuf.callback(soundBuf.userdata /*blah */ , (u8 *) ((unsigned int)buffer + offs), soundBuf.samples << shiftVal); //FIXME (*callback)(param) ? + frame = t; + } } +int GpSoundBufStart(GPSOUNDBUF *sb) { + frame = 0; + + /* Copy the structure */ + memcpy(&soundBuf, sb, sizeof(GPSOUNDBUF)); + + /* Calculate size of a single sample in bytes + * and a corresponding shift value + */ + shiftVal = 0; + switch (soundBuf.freq) { + case PCM_S11: + break; + case PCM_S22: + break; + case PCM_S44: + shiftVal++; + break; + case PCM_M11: + break; + case PCM_M22: + break; + case PCM_M44: + shiftVal++; + break; + } + if (soundBuf.format == PCM_16BIT) + shiftVal++; + soundBuf.samplesize = 1 << shiftVal; + + /* Allocate memory for the playing buffer */ + buffer = malloc(soundBuf.samplesize * soundBuf.samples * 2); + memset(buffer, 0, soundBuf.samplesize * soundBuf.samples * 2); + + /* Set timer interrupt #0 */ + if (GpTimerOptSet(0, soundBuf.pollfreq, 0, + soundtimer) == GPOS_ERR_ALREADY_USED) + error("timer slot used"); + GpTimerSet(0); + /* Start playing */ + GpPcmPlay((unsigned short *)buffer, + soundBuf.samples * soundBuf.samplesize * 2, 1); + GpPcmLock((unsigned short *)buffer, (int *)&idx_buf, + (unsigned int *)&soundPos); + + return 0; +} + +void GpSoundBufStop(void) { + GpPcmStop(); + GpPcmRemove((unsigned short *)buffer); + GpTimerKill(0); + free(buffer); +} + +int OSystem_GP32::getOutputSampleRate() const { + return SAMPLES_PER_SEC; +} + +// Set the function to be invoked whenever samples need to be generated +// Buffer Length and Poll Frequency changed. DJWillis +bool OSystem_GP32::setSoundCallback(SoundProc proc, void *param) { + gpsndbuf.freq = PCM_S22; // Taken from gpmm.h + gpsndbuf.format = PCM_16BIT; // Taken from gpmm.h + gpsndbuf.samples = 2048; //128; //fixme? // Buffer length (in samples) + //FIXME? crashes if not commented?! + //gpsndbuf.userdata=g_scumm; //param; //fixme? // Userdata which gets passed to the callback function + gpsndbuf.callback = proc; //mycallback; // Callback function (just like in SDL) + //2*((float)22025/(float)s.samples); + gpsndbuf.pollfreq = 8 * (SAMPLES_PER_SEC / gpsndbuf.samples); //fixme + // Frequency of the timer interrupt which polls the playing position + // recommended value: 2*(playingfreq in Hz/GPSOUNDBUF.samples) + //s.samplesize; // Size of one sample (8bit mono->1, 16bit stereo->4) - don't touch this + + GpPcmInit(PCM_S22, PCM_16BIT); + GpSoundBufStart(&gpsndbuf); + return true; +} + +///////////////////////////////////////////////////////////////////////////// +// +// GP32 Graphics Stuff +// +///////////////////////////////////////////////////////////////////////////// + void OSystem_GP32::get_screen_image(byte *buf) { /* make sure the mouse is gone */ undraw_mouse(); - - ///if (SDL_LockSurface(_screen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); - memcpy(buf, _screen->pixels, _screenWidth*_screenHeight); + ///if (gpLockSurface(_screen) == -1) + /// error("gpLockSurface failed: %s.\n", gpGetError()); - ///SDL_UnlockSurface(_screen); + memcpy(buf, _screen->pixels, _screenWidth * _screenHeight); + + ///gpUnlockSurface(_screen); } void OSystem_GP32::hotswap_gfx_mode() { @@ -971,8 +1656,8 @@ void OSystem_GP32::hotswap_gfx_mode() { * of the screen data during the change. Then we draw that to * the new screen right after it's setup. */ - - byte *bak_mem = (byte*)malloc(_screenWidth*_screenHeight); + + byte *bak_mem = (byte *) malloc(_screenWidth * _screenHeight); get_screen_image(bak_mem); @@ -980,174 +1665,206 @@ void OSystem_GP32::hotswap_gfx_mode() { load_gfx_mode(); // reset palette - SDL_SetColors(_screen, _currentPalette, 0, 256); + gpSetColors(_screen, _currentPalette, 0, 256); // blit image - copyRectToScreen(bak_mem, _screenWidth, 0, 0, _screenWidth, _screenHeight); + copyRectToScreen(bak_mem, _screenWidth, 0, 0, _screenWidth, + _screenHeight); free(bak_mem); updateScreen(); } - -// Get or set a property -uint32 OSystem_GP32::property(int param, Property *value) { - switch(param) { - case PROP_GET_FULLSCREEN: - return _full_screen; +// Get or set a property +//uint32 OSystem_GP32::property(int param, Property *value) +//{ +// switch(param) { +// +// case PROP_GET_FULLSCREEN: +// return _full_screen; +//} - case PROP_OPEN_CD: //fixme? - /*if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1) - _cdrom = NULL; - else { - _cdrom = SDL_CDOpen(value->cd_num); - // Did if open? Check if _cdrom is NULL - if (!_cdrom) { - warning("Couldn't open drive: %s\n", SDL_GetError()); - } - }*/ - break; +void OSystem_GP32::setWindowCaption(const char *caption) { + //gGameName = caption; // Would like to return game here like DC port. - DJWillis +} - case PROP_SET_GFX_MODE: - if (value->gfx_mode >= 7) - return 0; - _mode = value->gfx_mode; - hotswap_gfx_mode(); +// CDROM Code - All returns false as the GP32 has no CDROM ;-) - return 1; +bool OSystem_GP32::openCD(int drive) { + return false; +} - case PROP_GET_SAMPLE_RATE: - ///return SAMPLES_PER_SEC; //ph0x fixme - return 22050; - } +bool OSystem_GP32::pollCD() { + return false; +} - return 0; +void OSystem_GP32::playCD(int track, int num_loops, int start_frame, int duration) { } - -// Poll cdrom status -// Returns true if cd audio is playing -bool OSystem_GP32::pollCD() { return false; } -// Play cdrom audio track -void OSystem_GP32::playCD(int track, int num_loops, int start_frame, int duration) { } +void OSystem_GP32::stopCD() { +} -// Stop cdrom audio track -void OSystem_GP32::stopCD() { } +void OSystem_GP32::updateCD() { +} -// Update cdrom audio status -void OSystem_GP32::updateCD() { } +// End CDROM Code. // Add a new callback timer -void OSystem_GP32::setTimerCallback(TimerProc callback, int timer) { } -// Mutex handling -OSystem::MutexRef OSystem_GP32::createMutex() { +// ph0x FIXME: make members +int _timerinterval; +int (*_timercallback)(int); + +void voidcallback() { + //printf("timer running"); + _timercallback(_timerinterval); //FIXME ?? (*_timercallback)(_timerinterval); +} + +void OSystem_GP32::setTimerCallback(TimerProc callback, int timer) { + int timerno = 1; //0 used by sound proc + + if (!callback) { + GpTimerKill(timerno); + return; + } + + if (GpTimerOptSet(timerno, timer, 0, + voidcallback) == GPOS_ERR_ALREADY_USED) + error("timer slot used"); + + _timerinterval = timer; + _timercallback = callback; + GpTimerSet(timerno); +} + +// Mutex handling - DJWillis Hack +OSystem::MutexRef OSystem_GP32::createMutex(void) { return NULL; } -void OSystem_GP32::lockMutex(MutexRef mutex) { } -void OSystem_GP32::unlockMutex(MutexRef mutex) { } -void OSystem_GP32::deleteMutex(MutexRef mutex) { } + +void OSystem_GP32::lockMutex(MutexRef) { +} + +void OSystem_GP32::unlockMutex(MutexRef) { +} + +void OSystem_GP32::deleteMutex(MutexRef) { +} // Quit -void gphalt(int); -void OSystem_GP32::quit() { +void OSystem_GP32::quit() { + printf("Quitting..."); exit(0); } - + // Overlay -void OSystem_GP32::showOverlay() { +void OSystem_GP32::showOverlay() { // hide the mouse - undraw_mouse(); -u8* s=(u8*)_screen->pixels; -u16* d=(u16*)sdl_tmpscreen->pixels; -u8 c; -// convert to 16 bit -for (int y=0; y<200; y++) { - for (int x=0; x<320; x++) { - c=*s; - *d++ = (u16)GP_RGB16(_currentPalette[c].r, _currentPalette[c].g, _currentPalette[c].b); - s++; - } - d+=3; // tmpscreen width is screen+3 -} -GpGraphicModeSet(16, NULL); //ph0x -//GpRectFill(NULL,&gpDraw[GAME_SURFACE], 0, 0, 320, 240*2, 0); //black border - - _overlay_visible = true; + u8 *s = (u8 *) _screen->pixels; + u16 *d = (u16 *) _tmpscreen->pixels; + u8 c; + // convert to 16 bit + for (int y = 0; y < _screenHeight; y++) { + for (int x = 0; x < 320; x++) { + c = *s; + *d++ = + (u16) gpRGB16(_currentPalette[c].r, + _currentPalette[c].g, _currentPalette[c].b); + s++; + } + d += 3; // tmpscreen width is screen+3 + } + GpGraphicModeSet(16, NULL); //ph0x + // Test code. + //??????????? + //GpRectFill(NULL,&LCDbuffer[GAME_SURFACE], 0, 0, 320, 240, 0); //black border + _overlayVisible = true; clearOverlay(); } -void OSystem_GP32::hideOverlay() { +void OSystem_GP32::hideOverlay() { // hide the mouse undraw_mouse(); -GpGraphicModeSet(8, NULL); //ph0x -GpRectFill(NULL,&gpDraw[GAME_SURFACE], 0, 200, 320, 40, 0); //black border + GpGraphicModeSet(8, NULL); //ph0x + GpRectFill(NULL, &LCDbuffer[GAME_SURFACE], 0, 0, 320, 240, 0); //black border - _overlay_visible = false; + _overlayVisible = false; _forceFull = true; } -void OSystem_GP32::clearOverlay() { - if (!_overlay_visible) +void OSystem_GP32::clearOverlay() { + if (!_overlayVisible) return; - + // hide the mouse undraw_mouse(); // Clear the overlay by making the game screen "look through" everywhere. - SDL_Rect src, dst; + gpRect src, dst; src.x = src.y = 0; dst.x = dst.y = 1; src.w = dst.w = _screenWidth; src.h = dst.h = _screenHeight; - if (SDL_BlitSurface(_screen, &src, sdl_tmpscreen, &dst) != 0) //FIXME - error("SDL_BlitSurface failed: %s", SDL_GetError()); - + if (gpBlitSurface(_screen, &src, _tmpscreen, &dst) != 0) //FIXME + error("gpBlitSurface failed: %s", gpGetError()); _forceFull = true; } -void OSystem_GP32::grabOverlay(int16 *buf, int pitch) { - if (!_overlay_visible) +void OSystem_GP32::grabOverlay(int16 *buf, int pitch) { + if (!_overlayVisible) return; - if (sdl_tmpscreen == NULL) + if (_tmpscreen == NULL) return; // hide the mouse undraw_mouse(); - ///if (SDL_LockSurface(sdl_tmpscreen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); + ///if (gpLockSurface(_tmpscreen) == -1) + /// error("gpLockSurface failed: %s.\n", gpGetError()); - int16 *src = (int16 *)sdl_tmpscreen->pixels + TMP_SCREEN_WIDTH + 1; + int16 *src = (int16 *) _tmpscreen->pixels + TMP_SCREEN_WIDTH + 1; int h = _screenHeight; do { - memcpy(buf, src, _screenWidth*2); + memcpy(buf, src, _screenWidth * 2); src += TMP_SCREEN_WIDTH; buf += pitch; } while (--h); - ///SDL_UnlockSurface(sdl_tmpscreen); + ///gpUnlockSurface(_tmpscreen); } -void OSystem_GP32::copyRectToOverlay(const int16 *buf, int pitch, int x, int y, int w, int h) { - if (!_overlay_visible) +void OSystem_GP32::copyRectToOverlay(const int16 * buf, int pitch, int x, + int y, int w, int h) { + if (!_overlayVisible) return; - if (sdl_tmpscreen == NULL) + if (_tmpscreen == NULL) return; // Clip the coordinates - if (x < 0) { w+=x; buf-=x; x = 0; } - if (y < 0) { h+=y; buf-=y*pitch; y = 0; } - if (w > _screenWidth-x) { w = _screenWidth - x; } - if (h > _screenHeight-y) { h = _screenHeight - y; } + if (x < 0) { + w += x; + buf -= x; + x = 0; + } + if (y < 0) { + h += y; + buf -= y * pitch; + y = 0; + } + if (w > _screenWidth - x) { + w = _screenWidth - x; + } + if (h > _screenHeight - y) { + h = _screenHeight - y; + } if (w <= 0 || h <= 0) return; - + // Mark the modified region as dirty cksum_valid = false; add_dirty_rect(x, y, w, h); @@ -1155,147 +1872,666 @@ void OSystem_GP32::copyRectToOverlay(const int16 *buf, int pitch, int x, int y, /* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */ undraw_mouse(); - ///if (SDL_LockSurface(sdl_tmpscreen) == -1) - /// error("SDL_LockSurface failed: %s.\n", SDL_GetError()); + ///if (gpLockSurface(_tmpscreen) == -1) + /// error("gpLockSurface failed: %s.\n", gpGetError()); - int16 *dst = (int16 *)sdl_tmpscreen->pixels + (y+1) * TMP_SCREEN_WIDTH + (x+1); + int16 *dst = + (int16 *) _tmpscreen->pixels + (y + 1) * TMP_SCREEN_WIDTH + (x + + 1); do { - memcpy(dst, buf, w*2); + memcpy(dst, buf, w * 2); dst += TMP_SCREEN_WIDTH; buf += pitch; } while (--h); - ///SDL_UnlockSurface(sdl_tmpscreen); + ///gpUnlockSurface(_tmpscreen); } -OSystem *OSystem_GP32::create(int gfx_mode, bool full_screen) { - OSystem_GP32 *syst = new OSystem_GP32(); - - syst->_mode = gfx_mode; - syst->_full_screen = full_screen; - - // allocate palette storage - syst->_currentPalette = (SDL_Color*)calloc(sizeof(SDL_Color), 256); +void OSystem_GP32::internUpdateScreen() { + assert(_hwscreen != NULL); - // allocate the dirty rect storage - syst->_mouseBackup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2); - return syst; + // If the shake position changed, fill the dirty area with blackness + + if (_currentShakePos != _newShakePos) { + + gpRect blackrect = + { 0, 0, _screenWidth * _scaleFactor, + _newShakePos * _scaleFactor }; + + //if (_adjustAspectRatio) + // blackrect.h = real2Aspect(blackrect.h - 1) + 1; + + gpFillRect(_hwscreen, &blackrect, 0); + + _currentShakePos = _newShakePos; + + _forceFull = true; + } + // Make sure the mouse is drawn, if it should be drawn. + draw_mouse(); + + // Check whether the palette was changed in the meantime and update the + // screen surface accordingly. + if (_paletteDirtyEnd != 0) { + + gpSetColors(_screen, _currentPalette + _paletteDirtyStart, + _paletteDirtyStart, _paletteDirtyEnd - _paletteDirtyStart); + + _paletteDirtyEnd = 0; + + _forceFull = true; + } +//#ifdef USE_OSD +// // OSD visible (i.e. non-transparent)? +// if (_osdAlpha != gpALPHA_TRANSPARENT) { +// // Updated alpha value +// const int diff = gpGetTicks() - _osdFadeStartTime; +// if (diff > 0) { +// if (diff >= kOSDFadeOutDuration) { +// // Back to full transparency +// _osdAlpha = gpALPHA_TRANSPARENT; +// } else { +// // Do a linear fade out... +// const int startAlpha = gpALPHA_TRANSPARENT + kOSDInitialAlpha * (gpALPHA_OPAQUE - gpALPHA_TRANSPARENT) / 100; +// _osdAlpha = startAlpha + diff * (gpALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration; +// } +// gpSetAlpha(_osdSurface, gpRLEACCEL | gpSRCCOLORKEY | gpSRCALPHA, _osdAlpha); +// _forceFull = true; +// } +// } +//#endif + + // Force a full redraw if requested + if (_forceFull) { + _num_dirty_rects = 1; + + _dirty_rect_list[0].x = 0; + _dirty_rect_list[0].y = 0; + _dirty_rect_list[0].w = _screenWidth; + _dirty_rect_list[0].h = _screenHeight; + } + // Only draw anything if necessary + if (_num_dirty_rects > 0) { + + gpRect *r; + gpRect dst; + uint32 srcPitch, dstPitch; + gpRect *last_rect = _dirty_rect_list + _num_dirty_rects; + + if (_scaler_proc == Normal1x && !_adjustAspectRatio) { + + gpSurface *target = + _overlayVisible ? _tmpscreen : _screen; + for (r = _dirty_rect_list; r != last_rect; ++r) { + dst = *r; + + if (_overlayVisible) { + // FIXME: I don't understand why this is necessary... + dst.x--; + dst.y--; + } + dst.y += _currentShakePos; + if (gpBlitSurface(target, r, _hwscreen, + &dst) != 0) + error("gpBlitSurface failed: %s", + gpGetError()); + } + } else { + if (!_overlayVisible) { + + for (r = _dirty_rect_list; r != last_rect; ++r) { + dst = *r; + dst.x++; // Shift rect by one since 2xSai needs to acces the data around + dst.y++; // any pixel to scale it, and we want to avoid mem access crashes. + if (gpBlitSurface(_screen, r, + _tmpscreen, &dst) != 0) + error + ("gpBlitSurface failed: %s", + gpGetError()); + } + } + //gpLockSurface(_tmpscreen); + //gpLockSurface(_hwscreen); + + srcPitch = _tmpscreen->pitch; + dstPitch = _hwscreen->pitch; + + for (r = _dirty_rect_list; r != last_rect; ++r) { + + register int dst_y = r->y + _currentShakePos; + register int dst_h = 0; + register int orig_dst_y = 0; + + if (dst_y < _screenHeight) { + dst_h = r->h; + if (dst_h > _screenHeight - dst_y) + dst_h = _screenHeight - dst_y; + + dst_y *= _scaleFactor; + + if (_adjustAspectRatio) { + orig_dst_y = dst_y; + dst_y = real2Aspect(dst_y); + + } + + _scaler_proc((byte *) _tmpscreen-> + pixels + (r->x * 2 + 2) + (r->y + + 1) * srcPitch, srcPitch, + (byte *) _hwscreen->pixels + + r->x * 2 * _scaleFactor + + dst_y * dstPitch, dstPitch, r->w, + dst_h); + } + + r->x *= _scaleFactor; + r->y = dst_y; + r->w *= _scaleFactor; + r->h = dst_h * _scaleFactor; + + if (_adjustAspectRatio + && orig_dst_y / _scaleFactor < + _screenHeight) + r->h = + stretch200To240((uint8 *) + _hwscreen->pixels, dstPitch, r->w, + r->h, r->x, r->y, orig_dst_y); + } + //gpUnlockSurface(_tmpscreen); + //gpUnlockSurface(_hwscreen); + + } + + // Readjust the dirty rect list in case we are doing a full update. + // This is necessary if shaking is active. + if (_forceFull) { + _dirty_rect_list[0].y = 0; + _dirty_rect_list[0].h = 240; + + } +#ifdef USE_OSD + if (_osdAlpha != gpALPHA_TRANSPARENT) { + gpBlitSurface(_osdSurface, 0, _hwscreen, 0); + } +#endif + + // Finally, blit all our changes to the screen + gpUpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list); + + } + + _num_dirty_rects = 0; + _forceFull = false; } -OSystem *OSystem_GP32_create(int gfx_mode, bool full_screen) { - return OSystem_GP32::create(gfx_mode, full_screen); // fullscreen +// assert(_hwscreen != NULL); +// +// // If the shake position changed, fill the dirty area with blackness +// if (_currentShakePos != _newShakePos) { +// gpRect blackrect = {0, 0, _screenWidth*_scaleFactor, _newShakePos*_scaleFactor}; +// gpFillRect(_hwscreen, &blackrect, 0); +// +// _currentShakePos = _newShakePos; +// +// _forceFull = true; +// } +// +// // Make sure the mouse is drawn, if it should be drawn. +// draw_mouse(); //ph0x +// +// // Check whether the palette was changed in the meantime and update the +// // screen surface accordingly. +// if (_paletteDirtyEnd != 0) { +// gpSetColors(_screen, _currentPalette + _paletteDirtyStart, +// _paletteDirtyStart, +// _paletteDirtyEnd - _paletteDirtyStart); +// +// _paletteDirtyEnd = 0; +// +// _forceFull = true; +// } +// +// // Force a full redraw if requested +// if (_forceFull) { +// _num_dirty_rects = 1; +// +// _dirty_rect_list[0].x = 0; +// _dirty_rect_list[0].y = 0; +// _dirty_rect_list[0].w = _screenWidth; +// _dirty_rect_list[0].h = _screenHeight; +// } +// +// // Only draw anything if necessary +// if (_num_dirty_rects > 0) { +// +// gpRect *r; +// uint32 srcPitch, dstPitch; +// gpRect *last_rect = _dirty_rect_list + _num_dirty_rects; +// +// // Convert appropriate parts of the 8bpp image into 16bpp +// if (!_overlayVisible) { +// gpRect dst; +// for(r = _dirty_rect_list; r != last_rect; ++r) { +// dst = *r; +// dst.x++; // FIXME? Shift rect by one since 2xSai needs to acces the data around +// dst.y++; // FIXME? any pixel to scale it, and we want to avoid mem access crashes. +// +// if (gpBlitSurface(_screen, r, _hwscreen, &dst) != 0) //ph0x! gp_tmpscreen +// error("gpBlitSurface failed: %s", gpGetError()); +// } +// } +// +// ///gp_LockSurface(gp_tmpscreen); +// ///gp_LockSurface(gp_hwscreen); +// +//// ph0x! (no scaling) cannot skip intro if commented? +// +// srcPitch = _tmpscreen->pitch; +// dstPitch = _hwscreen->pitch; +// for(r = _dirty_rect_list; r != last_rect; ++r) { +// register int dst_y = r->y + _currentShakePos; +// register int dst_h = 0; +// if (dst_y < _screenHeight) { +// dst_h = r->h; +// if (dst_h > _screenHeight - dst_y) +// dst_h = _screenHeight - dst_y; +// +// dst_y *= _scaleFactor; +// +// if (_overlayVisible) //ph0x fixme? +// _scaler_proc((byte*)_tmpscreen->pixels + (r->x*2+2) + (r->y+1)*srcPitch, srcPitch, +// (byte*)_hwscreen->pixels + r->x*2*_scaleFactor + dst_y*dstPitch, dstPitch, r->w, dst_h); +// } +// r->x *= _scaleFactor; +// r->y = dst_y; +// r->w *= _scaleFactor; +// r->h = dst_h * _scaleFactor; +// } +// +// ///gp_UnlockSurface(gp_tmpscreen); +// ///gp_UnlockSurface(gp_hwscreen); +// +// // Readjust the dirty rect list in case we are doing a full update. +// // This is necessary if shaking is active. +// if (_forceFull) { +// _dirty_rect_list[0].y = 0; +// _dirty_rect_list[0].h = _screenHeight * _scaleFactor; +// } +// +// // Finally, blit all our changes to the screen +// +// // FIXME (dont use condition) +// if (_overlayVisible) +// gpUpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list); //ph0x! gp_hwscreen +// else +// gpUpdateRects(_screen, _num_dirty_rects, _dirty_rect_list); +// } +// +// _num_dirty_rects = 0; +// _forceFull = false; +//} + +void OSystem_GP32::setFeatureState(Feature f, bool enable) { + + switch (f) { + case kFeatureFullscreenMode: + setFullscreenMode(enable); + break; + case kFeatureAspectRatioCorrection: + if (_screenHeight == 200 && _adjustAspectRatio != enable) { + Common::StackLock lock(_graphicsMutex); + + //assert(_hwscreen != 0); + _adjustAspectRatio ^= true; + hotswap_gfx_mode(); + +#ifdef USE_OSD + char buffer[128]; + if (_adjustAspectRatio) + sprintf(buffer, + "Enabled aspect ratio correction\n%d x %d -> %d x %d", + _screenWidth, _screenHeight, _hwscreen->w, + _hwscreen->h); + else + sprintf(buffer, + "Disabled aspect ratio correction\n%d x %d -> %d x %d", + _screenWidth, _screenHeight, _hwscreen->w, + _hwscreen->h); + displayMessageOnOSD(buffer); +#endif + + // Blit everything to the screen + internUpdateScreen(); + + // Make sure that an EVENT_SCREEN_CHANGED gets sent later + _modeChanged = true; + } + break; + case kFeatureAutoComputeDirtyRects: + if (enable) + _mode_flags |= DF_WANT_RECT_OPTIM; + else + _mode_flags &= ~DF_WANT_RECT_OPTIM; + break; + default: + break; + } } -////////////////////////////////////////////////// -// GP32 stuff -////////////////////////////////////////////////// +bool OSystem_GP32::hasFeature(Feature f) { + return false; + (f == kFeatureFullscreenMode) || (f == kFeatureAspectRatioCorrection); + // || +// (f == kFeatureAutoComputeDirtyRects); +} -extern "C" int write(int fd, void *p, size_t n); -int write(int fd, void *p, size_t n) { return 0; } //ph0x hack! +bool OSystem_GP32::getFeatureState(Feature f) { -// Converts 8bit rgb values to a GP32 palette value -void GpSetPaletteEntry(u8 i, u8 r, u8 g, u8 b) { - GP_PALETTEENTRY entry = GP_RGB16(r,g,b); - GpPaletteEntryChange ( i, 1, &entry, 0 ); + switch (f) { + case kFeatureFullscreenMode: + return _full_screen; + case kFeatureAspectRatioCorrection: + return _adjustAspectRatio; + case kFeatureAutoComputeDirtyRects: + return _mode_flags & DF_WANT_RECT_OPTIM; + default: + return false; + } } -void switchsurf(int surf) { - GPLCDINFO lcd; - GpLcdInfoGet(&lcd); +void OSystem_GP32::setFullscreenMode(bool enable) { + Common::StackLock lock(_graphicsMutex); - if (surf == DEBUG_SURFACE) { - if (lcd.lcd_global.U8_lcd.bpp == 16) - GpGraphicModeSet(8, NULL); + if (_full_screen != enable) { + assert(_hwscreen != 0); + _full_screen ^= true; + undraw_mouse(); - currsurface = DEBUG_SURFACE; - GpSurfaceFlip(&gpDraw[currsurface]); - GpSetPaletteEntry(0, 0, 0, 0); - GpSetPaletteEntry(1, 255, 0, 0); - GpSetPaletteEntry(2, 255, 255, 255); - } else { - if (surf == GAME_SURFACE) { - currsurface = GAME_SURFACE; - GpSurfaceFlip(&gpDraw[currsurface]); + //if (!gpWM_ToggleFullScreen(_hwscreen)) { + // if ToggleFullScreen fails, achieve the same effect with hotswap gfx mode + // hotswap_gfx_mode(); + //} + +#ifdef USE_OSD + if (_full_screen) + displayMessageOnOSD("Fullscreen mode"); + else + displayMessageOnOSD("Windowed mode"); +#endif + + // Blit everything to the screen + internUpdateScreen(); + + // Make sure that an EVENT_SCREEN_CHANGED gets sent later + _modeChanged = true; + } +} + +static const OSystem::GraphicsMode supportedGraphicsModes[] = { + {"1x", "320x240 16bpp", GFX_NORMAL}, + {0, 0, 0} +}; + +const OSystem::GraphicsMode *OSystem_GP32::getSupportedGraphicsModes() const { + return supportedGraphicsModes; +} + +int OSystem_GP32::getDefaultGraphicsMode() const { + return GFX_NORMAL; +} + +bool OSystem_GP32::setGraphicsMode(int mode) { + + Common::StackLock lock(_graphicsMutex); + + int newScaleFactor = 1; + ScalerProc *newScalerProc; + + switch (mode) { + case GFX_NORMAL: + newScaleFactor = 1; + newScalerProc = Normal1x; + break; + //case GFX_DOUBLESIZE: + // newScaleFactor = 2; + // newScalerProc = Normal2x; + // break; + //case GFX_TRIPLESIZE: + // newScaleFactor = 3; + // newScalerProc = Normal3x; + // break; + //case GFX_2XSAI: + // newScaleFactor = 2; + // newScalerProc = _2xSaI; + // break; + //case GFX_SUPER2XSAI: + // newScaleFactor = 2; + // newScalerProc = Super2xSaI; + // break; + //case GFX_SUPEREAGLE: + // newScaleFactor = 2; + // newScalerProc = SuperEagle; + // break; + //case GFX_ADVMAME2X: + // newScaleFactor = 2; + // newScalerProc = AdvMame2x; + // break; + //case GFX_ADVMAME3X: + // newScaleFactor = 3; + // newScalerProc = AdvMame3x; + // break; + //case GFX_HQ2X: + // newScaleFactor = 2; + // newScalerProc = HQ2x; + // break; + //case GFX_HQ3X: + // newScaleFactor = 3; + // newScalerProc = HQ3x; + // break; + //case GFX_TV2X: + // newScaleFactor = 2; + // newScalerProc = TV2x; + // break; + //case GFX_DOTMATRIX: + // newScaleFactor = 2; + // newScalerProc = DotMatrix; + // break; + + default: + warning("unknown gfx mode %d", mode); + return false; + } + + _mode = mode; + _scaler_proc = newScalerProc; + if (newScaleFactor != _scaleFactor) { + _scaleFactor = newScaleFactor; + hotswap_gfx_mode(); + } + + if (!_screen) + return true; + +#ifdef USE_OSD + if (_osdSurface) { + const char *newScalerName = 0; + const GraphicsMode *g = s_supportedGraphicsModes; + while (g->name) { + if (g->id == mode) { + newScalerName = g->description; + break; + } + g++; + } + if (newScalerName) { + char buffer[128]; + sprintf(buffer, + "Active graphics filter: %s\n%d x %d -> %d x %d", + newScalerName, _screenWidth, _screenHeight, + _hwscreen->w, _hwscreen->h); + displayMessageOnOSD(buffer); } } - +#endif + + // Blit everything to the screen + _forceFull = true; + internUpdateScreen(); + + // Make sure that an EVENT_SCREEN_CHANGED gets sent later + _modeChanged = true; + + return true; +} + +int OSystem_GP32::getGraphicsMode() const { + return _mode; } -int gpprintf(const char *fmt, ...) { //return 0; //fixme +////OSystem *OSystem_GP32::create(int gfx_mode, bool full_screen) +//OSystem *OSystem_GP32::create() +//{ +// //OSystem_GP32 *syst = new OSystem_GP32(); +// +// //syst->_mode = gfx_mode; +// //syst->_full_screen = full_screen; +// // +// //// allocate palette storage +// //syst->_currentPalette = (gpColor*)calloc(sizeof(gpColor), 256); +// +// //// allocate the dirty rect storage +// //syst->_mouseBackup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2); +// /*return syst;*/ +// return new OSystem_GP32(); +//} + +////////////////////////////////////////////////// +// GP32 stuff +////////////////////////////////////////////////// + +extern "C" int write(int fd, void *p, size_t n); +int write(int fd, void *p, size_t n) { //ph0x hack! + return 0; +} + +// Converts 8bit rgb values to a GP32 palette value +void GpSetPaletteEntry(u8 i, u8 r, u8 g, u8 b) { + GP_PALETTEENTRY entry = gpRGB16(r, g, b); + GpPaletteEntryChange(i, 1, &entry, 0); +} + +int gpprintf(const char *fmt, ...) { + static bool busy; static int y; - char s[1024]; // ? - int r; + char s[1024]; // ? va_list marker; - - // combine + + if (busy) + return 0; + busy = true; va_start(marker, fmt); - r = vsprintf(s, fmt, marker); - va_end(marker); - // print to console + vsprintf(s, fmt, marker); + va_end(marker); -#ifdef GPDEBUG -//dprintf("mem: %d ", gm_availablesize()); +#ifdef GPDEBUG + //dprintf("mem: %d ", gm_availablesize()); dprintf(s); - if (s[strlen(s)-1] != '\n') dprintf("\n"); + if (s[strlen(s) - 1] != '\n') + dprintf("\n"); //if (s[0]!='>') return r; -#endif - +#endif + + fprintf(stdout, s); + // print to lcd - GpTextOut(NULL, &gpDraw[DEBUG_SURFACE], 0, y, s, 1); - y+= (ENGFONT_H-FONT_LINEGAP); - if (y>(240/(ENGFONT_H-FONT_LINEGAP)) * (ENGFONT_H-FONT_LINEGAP)) { - y=0; - GpRectFill(NULL,&gpDraw[DEBUG_SURFACE], 0, 0, 320, 240, 2); + GpTextOut(NULL, &LCDbuffer[DEBUG_SURFACE], 0, y, s, 1); + y += (ENGFONT_H - FONT_LINEGAP); + if (y > + (240 / (ENGFONT_H - FONT_LINEGAP)) * (ENGFONT_H - FONT_LINEGAP)) { + y = 0; + GpRectFill(NULL, &LCDbuffer[DEBUG_SURFACE], 0, 0, 320, 240, 2); } - return r; + busy = false; + return 0; } int gpfprintf(FILE *stream, const char *fmt, ...) { - //printf(fmt, "fixme"); + char s[256]; + va_list marker; + + va_start(marker, fmt); + vsprintf(s, fmt, marker); + va_end(marker); + + return fwrite(s, 1, strlen(s), stream); } -FILE *gpfopen(const char *filename, const char *mode) { - //FIXME: - // - allocation ? - // - mode - // - malloc -> new +typedef struct { + FILE f; + ulong size; + ulong p; //cache position +} xfile; + +#define XFILE(f) (*(xfile*)f) +#define FCACHE_SIZE 8*1024 // speed up writes + +FILE *gpfopen(const char *filename, const char *mode) { + //FIXME: allocation, mode, malloc -> new ulong m; - FILE *f = (FILE*)malloc(sizeof(FILE) + sizeof(ulong)); + FILE *f; + ERR_CODE err; + char s[256]; + if (!strchr(filename, '.')) { + sprintf(s, "%s.", filename); + filename = s; + } //printf(">open %s as %s", filename, mode); // FIXME add binary/text support - if (tolower(mode[0])=='r') { - m=OPEN_R; - GpFileGetSize(filename, (ulong*)(f+1)); // hack (size in handle :) - } else - if (tolower(mode[0])=='w') { + if (tolower(mode[0]) == 'r') { + f = (FILE *) malloc(sizeof(xfile)); + m = OPEN_R; + GpFileGetSize(filename, &XFILE(f).size); + err = GpFileOpen(filename, m, f); + } else if (tolower(mode[0]) == 'w') { //printf("open if as W"); + f = (FILE *) malloc(sizeof(xfile) + FCACHE_SIZE); + XFILE(f).size = 0; // FIXME? new file has no size? + XFILE(f).p = 0; + m = OPEN_W; + err = GpFileCreate(filename, ALWAYS_CREATE, f); + } else + error("wrong file mode"); - *(ulong*)(f+1)=0; // FIXME? new file has no size? - m=OPEN_W; - GpFileCreate(filename, ALWAYS_CREATE, f); - } - else error("wrong file mode"); - - if (!f) error("%s: cannot crate F_HANDLE", __FUNCTION__); - ERR_CODE err = GpFileOpen(filename, m, f); + if (!f) + error("%s: cannot crate F_HANDLE", __FUNCTION__); if (err) { - //if (strcmp(filename, "tentacle.000")==0 || strcmp(filename, "TENTACLE.000")==0) error(">bingo!"); - //if (blah>1) error("(%s) %s", filename, __FUNCTION__); else - return NULL; - } else return f; + //printf("IOerr %d", err); + return NULL; + } else + return f; } +int gpfclose(FILE *f) { + if (!f) { + //warning("closing null file"); + return 1; + } - -int gpfclose(FILE *stream) { - if (*(u32*)((char*)stream-sizeof(u32)) == 0x4321) { - debug(0, "double closing", __FUNCTION__); + if (*(u32 *)((char *)f - sizeof(u32)) == 0x4321) { + debug(0, "Double closing", __FUNCTION__); return 1; - } // return 1 ?? - ERR_CODE err = GpFileClose(*stream); - free(stream); + } // return 1 ?? + + if (XFILE(f).p) { + GpFileWrite(*f, (char *)f + sizeof(xfile), XFILE(f).p); // flush cache + XFILE(f).p = 0; + } + + ERR_CODE err = GpFileClose(*f); + free(f); + return err; } @@ -1303,112 +2539,163 @@ int gpfseek(FILE *stream, long offset, int whence) { ulong dummy; switch (whence) { - case SEEK_SET : whence = FROM_BEGIN; break; - case SEEK_CUR : whence = FROM_CURRENT; break; - case SEEK_END : whence = FROM_END; break; + case SEEK_SET: + whence = FROM_BEGIN; + break; + case SEEK_CUR: + whence = FROM_CURRENT; + break; + case SEEK_END: + whence = FROM_END; + break; } - return GpFileSeek(*stream, whence, offset, (long*)&dummy); + return GpFileSeek(*stream, whence, offset, (long *)&dummy); } -long gpftell(FILE *stream) { // fixme? use standard func - ulong pos=0; - ERR_CODE err = GpFileSeek(*stream, FROM_CURRENT, 0, (long*)&pos); +long gpftell(FILE *stream) { // fixme? use standard func + ulong pos = 0; + //ERR_CODE err = GpFileSeek(*stream, FROM_CURRENT, 0, (long*)&pos); return pos; } - size_t gpfread(void *ptr, size_t size, size_t n, FILE *stream) { - ulong readcount=0; - ERR_CODE err = GpFileRead(*stream, ptr, size*n, &readcount); //fixme? size*n - return readcount/size; //FIXME? + ulong readcount = 0; + //ERR_CODE err = GpFileRead(*stream, ptr, size*n, &readcount); //fixme? size*n + return readcount / size; //FIXME? } -size_t gpfwrite(const void *ptr, size_t size, size_t n, FILE *stream) { - ERR_CODE err=GpFileWrite(*stream, ptr, size*n); //fixme size*n? - //printf("writing to file"); - return err; +size_t gpfwrite(const void *ptr, size_t size, size_t n, FILE *f) { + int len = size * n; + + if (!f) { + //warning("writing to null file"); + return 0; + } + + if (XFILE(f).p + len < FCACHE_SIZE) { + memcpy((char *)f + sizeof(xfile) + XFILE(f).p, ptr, len); + XFILE(f).p += len; + } else { + if (XFILE(f).p) { + GpFileWrite(*f, (char *)f + sizeof(xfile), XFILE(f).p); // flush cache + XFILE(f).p = 0; + } + + ERR_CODE err = GpFileWrite(*f, ptr, len); + if (!err) + return n; + else + return -err; + } + return 0; } void gpclearerr(FILE *stream) { - //error("fixme: %s", __FUNCTION__); + //warning("fixme: %s", __FUNCTION__); } -int gpfeof(FILE *stream) { //fixme! - return ftell(stream) >= *(ulong*)(stream+1); +int gpfeof(FILE *f) { //fixme! + return ftell(f) >= XFILE(f).size; } char *gpfgets(char *s, int n, FILE *f) { - int err, i=0; + int i = 0; - while (!feof(f) && i<n) { + while (!feof(f) && i < n) { fread(&s[i], 1, 1, f); - if (s[i]=='\n') { - s[i+1]=0; + if (s[i] == '\n') { + s[i + 1] = 0; return s; } i++; } if (feof(f)) return NULL; - else return s; + else + return s; +} + +char gpfgetc(FILE *f) { + char c[1]; + + fread(&c[0], 1, 1, f); + return c[0]; +} + +int gpfflush(FILE * stream) { + return 0; } -int gpfflush(FILE *stream) { return 0;} +/* + * GP32 Memory managment. + */ void *gpmalloc(size_t size) { - void *p = gm_malloc(size+sizeof(u32)); // gm_zi_malloc(size+sizeof(u32)); + u32 np; + u32 *up; + + np = (u32) gm_malloc(size + sizeof(u32)); - //memset((char*)((char*)p+sizeof(u32)), 0, size); - //printf("callocing"); - if (p) { - *(u32*)p = 0x1234; - return ((char*)p+sizeof(u32)); - } else return NULL; + if (np) { + up = (u32 *) np; + *up = 0x1234; + return (void *)(np + sizeof(u32)); + } + + return NULL; } -void *gpcalloc(size_t nitems, size_t size) { - void *p = gpmalloc(nitems*size); //gpcalloc doesnt clear? - - memset(p, 0, nitems*size); - if (*(u8*)p) warning("%s: calloc doesn't clear!", __FUNCTION__); //fixme: was error - //printf("callocing"); - return p; +void *gpcalloc(size_t nitems, size_t size) { + void *p = gpmalloc(nitems * size); //gpcalloc doesnt clear? + + memset(p, 0, nitems * size); + if (*(u8 *) p) + warning("%s: calloc doesn't clear!", __FUNCTION__); //fixme: was error + //printf("callocing"); + return p; } void gpfree(void *block) { - if (!block) {debug(0, "freeing null pointer"); return;} - if (*(u32*)((char*)block-sizeof(u32)) == 0x4321) error("%s: double deallocation!", __FUNCTION__); - if (*(u32*)((char*)block-sizeof(u32)) != 0x1234) error("%s: corrupt block!", __FUNCTION__); - *(u32*)((char*)block-sizeof(u32)) = 0x4321; - gm_free((char*)block-sizeof(u32)); + u32 np; + u32 *up; + + if (!block) { + debug(0, "freeing null pointer"); + return; + } + + np = ((u32) block) - sizeof(u32); + up = (u32 *) np; + if (*up == 0x4321) + error("%s: double deallocation!", __FUNCTION__); + + if (*up != 0x1234) + error("%s: corrupt block!", __FUNCTION__); + *up = 0x4321; + + gm_free(up); } -void gphalt(int code=0) { - GpGraphicModeSet(8, NULL); - currsurface=DEBUG_SURFACE; - GpSurfaceFlip(&gpDraw[currsurface]); - GpSetPaletteEntry ( 0, 0,0,0 ); - GpSetPaletteEntry ( 1, 255,0,0 ); - GpSetPaletteEntry ( 2, 255,255,255 ); - printf("HALT!"); - while (1); +/* +char *gpstrdup(const char *s) { + char *p=(char*)malloc(strlen(s)+1); + memcpy(p, s, strlen(s)+1); + return p; } +*/ char *gpstrdup(const char *strSource) { - - char *buffer; - buffer = (char *)malloc(strlen(strSource) + 1); - if (buffer) - strcpy(buffer, strSource); - return buffer; + char *strBuffer; + strBuffer = (char *)malloc(strlen(strSource) + 1); + if (strBuffer) + strcpy(strBuffer, strSource); + return strBuffer; } time_t gptime(time_t *timer) { - time_t t = GpTickCountGet() / 1000; if (timer) *timer = t; - return t; } @@ -1419,116 +2706,516 @@ void gpdeinit() { } void gpexit(int code) { - switchsurf(DEBUG_SURFACE); - printf("Your GP32 will now restart..."); - gpdeinit(); - GpAppExit(); + if (!code) { + printf("----------------------------------------"); + printf(" Your GP32 is now restarting... "); + printf("----------------------------------------"); + + gpdeinit(); + + // FIXME: use function :) + int n = GpTickCountGet(); + while ((GpTickCountGet() - n) < 3000); + + GpAppExit(); + } else { + printf("Exit Code %d", code); + while (1); + } } -//#include <string.h> -#include "common/gamedetector.h" -VersionSettings* menu() { - const VersionSettings *v = version_settings; - VersionSettings* games[30]; - int n=0; +/**************************************************************** + Setup CPU Speed - Calls to CPUSPEED.S +****************************************************************/ +void gpCPUSpeed(int freq) { + // To extend use: cpu_speed(CLK_SPEED, DIV_FACTOR, CLK_MODE); + if (freq == 166) + cpu_speed(165000000, 0x2f001, 3); // 40 Bus? + if (freq == 156) + cpu_speed(156000000, 0x2c001, 3); // 36 Bus + if (freq == 133) + cpu_speed(133500000, (81 << 12) | (2 << 4) | 1, 2); // 66 Bus? + if (freq == 132) + cpu_speed(132000000, 0x3a011, 3); // 33 Bus + if (freq == 120) + cpu_speed(120000000, 0x24001, 2); + if (freq == 100) + cpu_speed(102000000, (43 << 12) | (1 << 4) | 1, 2); + if (freq == 66) + cpu_speed(67500000, (37 << 12) | (0 << 4) | 2, 2); + if (freq == 40) + cpu_speed(40000000, 0x48013, 1); // Default + if (freq == 33) + cpu_speed(33750000, (37 << 12) | (0 << 4) | 3, 2); // Ultra slow +} + +/**************************************************************** + Pre-ScummVM Configuration Menu. +****************************************************************/ +int ConfigMenu() { + //#ifndef GP32_GDB + // gpCPUSpeed(40); + //#endif /*GP32_GDB*/ + + GpSetPaletteEntry(2, 0, 0, 0); + GpSetPaletteEntry(1, 0, 0, 0); + GpSetPaletteEntry(0, 255, 255, 255); + + int i, key, fg, bg, choice = 0, y = ENGFONT_H * 7; + int n = ARRAYSIZE(menu); + + GpTextOut(NULL, &LCDbuffer[(int)currentsurf], 0, y, + "Configuration Menu", 1); + y += ENGFONT_H; + GpTextOut(NULL, &LCDbuffer[(int)currentsurf], 0, y, + "----------------------------------------", 1); + y += ENGFONT_H; - /*GpSetPaletteEntry ( 0, 0,0,0 ); - GpSetPaletteEntry ( 1, 255,0,0 ); - GpSetPaletteEntry ( 2, 255,255,255 );*/ + do { + for (i = 0; i < n; i++) { + if (i == choice) { + fg = 2; + bg = 1; + } else { + fg = 1; + bg = 2; + } + GpRectFill(NULL, &LCDbuffer[(int)currentsurf], 0, + y + i * ENGFONT_H, 320, ENGFONT_H, bg); + char s[256]; + sprintf(s, "%s [%s]", menu[i].option, + menu[i].submenu[menu[i].index]); + GpTextOut(NULL, &LCDbuffer[(int)currentsurf], 0, + y + i * ENGFONT_H, s, fg); + } - currsurface=GAME_SURFACE; - GpSurfaceFlip(&gpDraw[currsurface]); - printf("menu"); - - char s[256]; - while (v->filename && v->gamename) { - sprintf(s, "%s.000", v->filename); //fixme? (extension ok?) - FILE* f = fopen(s, "r"); - if (f) { - (const VersionSettings*)games[n++]=v; - fclose(f); + do + key = gpTrapKey(); + while (key == GPC_VK_NONE); + + if (key & GPC_VK_DOWN) { + if (choice < n - 1) + choice++; + } + if (key & GPC_VK_UP) { + if (choice > 0) + choice--; + } + if (key & GPC_VK_LEFT) { + if (menu[choice].index > 0) + menu[choice].index--; + } + if (key & GPC_VK_RIGHT) { + if (menu[choice].submenu[menu[choice].index + 1]) + menu[choice].index++; } - v++; + //if (key & GPC_VK_START || key & GPC_VK_FA) return 1; + if (key & GPC_VK_FA) + return 1; + //if (key & GPC_VK_SELECT) return 0; + + do + key = gpTrapKey(); + while (key != GPC_VK_NONE); + + } while (1); +} + +/**************************************************************** + Delay (very simple delay) +****************************************************************/ +void Delay(unsigned int ms) { + unsigned int delay_by; + delay_by = GpTickCountGet(); + while (GpTickCountGet() - delay_by < ms); +} + +/**************************************************************** + Triple buffering code +****************************************************************/ +void FlipScreen() { + if (nflip == 0) { + GpSurfaceFlip(&LCDbuffer[0]); + nflip = 1; + } else if (nflip == 1) { + GpSurfaceFlip(&LCDbuffer[1]); + nflip = 2; + } else if (nflip == 2) { + GpSurfaceFlip(&LCDbuffer[2]); + nflip = 0; + } +} + +/**************************************************************** + Clear all the screen buffers +****************************************************************/ +void ClearScreen() { + int i; + for (i = 0; i <= BUFFERCOUNT; i++) { + GpRectFill(NULL, &LCDbuffer[i], 0, 0, LCDbuffer[i].buf_w, + LCDbuffer[i].buf_h, 0x00); } +} - int i, key, fg, bg, choice=0, y=0; +/**************************************************************** + Fade to black +****************************************************************/ +void FadeToBlack(int delay_time) { + //Fade to black + int x; + for (x = 0; x < 30; x++) { + //Fade it further + GpLcdFade(-1, NULL); - //GpRectFill(NULL,&gpDraw[currsurface], 0, 0, 320, 200, 2); - GpTextOut(NULL, &gpDraw[currsurface], 0, y, "ScummVM (GP32 port by ph0x)", 255); y+=ENGFONT_H; + //refresh screen + GpSurfaceFlip(&LCDbuffer[nflip]); - if (!n) { - GpTextOut(NULL, &gpDraw[currsurface], 0, y, "No games found! put game data in gp:\\", 255); y+=ENGFONT_H; - while (1); + //wait a littel bit + Delay(delay_time); } - - - if (n==1) return games[choice]; //fixme? - GpTextOut(NULL, &gpDraw[currsurface], 0, y, "select game:", 255); y+=ENGFONT_H; - do { - for (i=0; i<n; i++) { - if (i==choice) {fg=100; bg=255;} else {fg=123; bg=0;} - GpRectFill(NULL,&gpDraw[currsurface], 0, y+i*ENGFONT_H, 320, ENGFONT_H, bg); - GpTextOut(NULL, &gpDraw[currsurface], 0, y+i*ENGFONT_H, (char*)games[i]->gamename, fg); - } - - do key=GpKeyGet(); while (key == GPC_VK_NONE) ; - if (key & GPC_VK_DOWN) - {if (choice<n-1) choice++;} else - if (key & GPC_VK_UP) - {if (choice>0) choice--;} else - if (key & GPC_VK_START || key & GPC_VK_FA) return games[choice]; //fixme? - do key=GpKeyGet(); while (key != GPC_VK_NONE) ; - - } while (1); + + //Now Clear all the buffers + ClearScreen(); + + //Turn the fading off + GpLcdNoFade(NULL); + + //Now flip to end it all and leave it black + FlipScreen(); } -int gpinit() { +/**************************************************************** + Fade to White +****************************************************************/ +void FadeToWhite(int delay_time) { + //Fade to black + int x; + for (x = 0; x < 30; x++) { + //Fade it further + GpLcdFade(1, NULL); - ERR_CODE err; - - //GpKeyInit(); + //refresh screen + GpSurfaceFlip(&LCDbuffer[nflip]); + + //wait a littel bit + Delay(delay_time); + } + + //Now Clear all the buffers + ClearScreen(); + + //Turn the fading off + GpLcdNoFade(NULL); + + //Now flip to end it all and leave it black + FlipScreen(); +} + +/**************************************************************** + Initialise the File System +****************************************************************/ +void InitFileSystem() { + //Initialises GP32 file system GpFatInit(); GpRelativePathSet("gp:\\gpmm"); + // Create folders on SMC if there not there + // For storing games, saves, config and scummvm.ini. + GpDirCreate("gp:\\data", NOT_IF_EXIST); + GpDirCreate("gp:\\data\\scummvm", NOT_IF_EXIST); + GpDirCreate("gp:\\data\\scummvm\\games", NOT_IF_EXIST); + GpDirCreate("gp:\\data\\scummvm\\config", NOT_IF_EXIST); +} + +/**************************************************************** + Splash Screen - show splash screen +****************************************************************/ + +void InitSplashPal() { + static GP_HPALETTE h_splash_pal = NULL; + if (h_splash_pal) + GpPaletteDelete(h_splash_pal); + h_splash_pal = GpPaletteCreate(gfx_splash_palnb, gfx_splash_Pal); + GpPaletteDelete(GpPaletteSelect(h_splash_pal)); + GpPaletteRealize(); +} + +int SplashScreen() { + int key; + + ClearScreen(); + InitSplashPal(); + + // Show the screen (load into all buffers - ready for screen transition) + GpBitBlt(NULL, &LCDbuffer[0], 0, 0, gfx_splash_width, + gfx_splash_height, (unsigned char *)gfx_splash, 0, 0, + gfx_splash_width, gfx_splash_height); + GpBitBlt(NULL, &LCDbuffer[1], 0, 0, gfx_splash_width, + gfx_splash_height, (unsigned char *)gfx_splash, 0, 0, + gfx_splash_width, gfx_splash_height); + GpBitBlt(NULL, &LCDbuffer[2], 0, 0, gfx_splash_width, + gfx_splash_height, (unsigned char *)gfx_splash, 0, 0, + gfx_splash_width, gfx_splash_height); + + // Refresh screen (show the logo) + FlipScreen(); + + // Initialise the File System + // Done during SpashScreen to hide folder create (if needed) from users. + InitFileSystem(); + + //TODO: Put branchs for Start and Select and act accordingly. + + do { + do + key = gpTrapKey(); + while (key == GPC_VK_NONE); + if (key & GPC_VK_START) { + FadeToBlack(20); + return 0; + } + if (key & GPC_VK_SELECT) { + FadeToWhite(20); + ConfigMenu(); + return 0; + } + do + key = gpTrapKey(); + while (key != GPC_VK_NONE); + } while (1); + + //Fade the screen into GP32 setup or ScummVM. + //FadeToWhite(100); +} + +/**************************************************************** + Read and write the GP32 config file to the SMC +****************************************************************/ +void ConfigRead() { + FILE *f; + + f = fopen("gp:\\data\\scummvm\\config\\config.dat", "r"); + + if (f) { + for (unsigned int i = 0; i < ARRAYSIZE(menu); i++) + fread(&menu[i].index, 1, sizeof(menu[i].index), f); + fclose(f); + } +} + +void ConfigWrite() { + FILE *f; + + f = fopen("gp:\\data\\scummvm\\config\\config.dat", "w"); + + if (f) { + for (unsigned int i = 0; i < ARRAYSIZE(menu); i++) + fwrite(&menu[i].index, 1, sizeof(menu[i].index), f); + fclose(f); + } +} + +/**************************************************************** + Prepare GP32 +****************************************************************/ +void InitLCD() { // Initialize graphics - GpGraphicModeSet(8, NULL); - GpLcdSurfaceGet(&gpDraw[DEBUG_SURFACE], DEBUG_SURFACE); - GpLcdSurfaceGet(&gpDraw[NAMEME_SURFACE], NAMEME_SURFACE); - GpLcdSurfaceGet(&gpDraw[GAME_SURFACE], GAME_SURFACE); - - GpSetPaletteEntry(0, 0, 0, 0); - GpSetPaletteEntry(1, 255, 0, 0); - GpSetPaletteEntry(2, 255, 255, 255); + GpGraphicModeSet(COLOUR_8BIT_MODE, NULL); - // fixme - use get function - currsurface=DEBUG_SURFACE; - GpSurfaceSet(&gpDraw[currsurface]); + // Set the current buffer + nflip = 0; - GpLcdEnable(); - -#ifdef GPDEBUG - printf(">waiting for debugger..."); - InitDebug(); -#endif - printf(">Running ScummVM"); + short i; + for (i = 0; i <= BUFFERCOUNT; i++) { + GpLcdSurfaceGet(&LCDbuffer[i], i); + } +} -} +void Init() { + // Setup the LCD. + InitLCD(); + + // Load the Splash Screen and give the option of config or ScummVM. + // also sets up file system. + SplashScreen(); + + //GpSetPaletteEntry ( 2, 0,0,0 ); + //GpSetPaletteEntry ( 1, 0,0,0 ); + //GpSetPaletteEntry ( 0, 255,255,255 ); + + //// fixme - use get function + ////currentsurf=DEBUG_SURFACE; + ////GpSurfaceSet(&LCDbuffer[(int)currentsurf]); + //GpSurfaceSet(&LCDbuffer[nflip]); + //GpLcdEnable(); + + //stderr = fstdout = fopen("gp:\\data\\scummvm\\config\\debug.out", "w"); + //stdin = NULL; //fixme? + ////fstdin = fopen("stdin", "w"); + ////fstderr = fopen("stderr", "w"); + + //printf(" ScummVM for the GP32"); + //printf("----------------------------------------"); + //printf("PRIVATE BUILD - DO NOT PASS ON!"); + //printf("ScummVM (c) 2001-4 The ScummVM Team"); + //printf("GP32 Backend (c) 2004 by DJWillis"); + //printf("Compiled %s, %s", __DATE__, __TIME__); + //printf("----------------------------------------"); + //printf(" Press 'A' to Start ScummVM"); + //printf("----------------------------------------"); + + ///* + //ERR_CODE err; + // + //unsigned long bad; + //err = GpFormat("gp:", FORMAT_RESCUE, &bad); + //char s[256]; + //GpRelativePathGet(s); + //*/ +} + +//void *gpmemset (void *s, int c, size_t n) { +// for (int i=n-1; i>=0; i--) +// ((char*)s)[i]=(char)c; +//} +// +//void *gpmemcpy (void *dest, const void *src, size_t n) { +// for (int i=n-1; i>=0; i--) +// ((char*)dest)[i]=((char*)src)[i]; +//} + +void buildgammatab(int val) { + float g = 1; + for (int i = 0; i < 256; i++) { + gammatab[255 - i] = g; + g *= scrGamma[val]; + } +} -extern "C" void GpMain (void * arg); // hack -void GpMain (void * arg) { - gpinit(); - - // fixme - use get function - currsurface=GAME_SURFACE; - GpSurfaceFlip(&gpDraw[currsurface]); +void buildgammatab2(int val) { + float g = 1; + for (int i = 0; i < 256; i++) { + gammatab2[255 - i] = g; + g *= scrGamma[val]; + } +} + +int stricmp(const char *string1, const char *string2) { + char src[4096]; + char dest[4096]; + int i; + + for (i = 0; i < strlen(string1); i++) + if (string1[i] >= 'A' && string1[i] <= 'Z') + src[i] = string1[i] + 32; + else + src[i] = string1[i]; + src[i] = 0; + + for (i = 0; i < strlen(string2); i++) + if (string2[i] >= 'A' && string2[i] <= 'Z') + dest[i] = string2[i] + 32; + else + dest[i] = string2[i]; + dest[i] = 0; + + return strcmp(src, dest); +} + +int strnicmp(const char *string1, const char *string2, int len) { + char src[4096]; + char dest[4096]; + int i; + + for (i = 0; i < strlen(string1) && i < len; i++) + if (string1[i] >= 'A' && string1[i] <= 'Z') + src[i] = string1[i] + 32; + else + src[i] = string1[i]; + src[i] = 0; + + for (i = 0; i < strlen(string2) && i < len; i++) + if (string2[i] >= 'A' && string2[i] <= 'Z') + dest[i] = string2[i] + 32; + else + dest[i] = string2[i]; + dest[i] = 0; + + return strncmp(src, dest, len); +} + +extern "C" void GpMain(void *arg); +extern "C" int scummvm_main(int argc, char *argv[]); - char *argv[] = { "scummvm", /*(char*)menu()->filename*/ NULL }; - int argc = 1; +void GpMain(void *arg) { - extern int main(int argc, char *argv[]); - main(argc, argv); - - error("returned from main ?!"); +#ifdef GP32_GDB + OpenUSB(); + InstallISR(); +#endif /*GP32_GDB */ + + // Wank up the GP32 good and propper ;-) + // asm volatile(" \n" + //" mov r0, #0x01 \n" + //" ldr r1, [r0] \n" + + //" \n" + //: + //: + //:"r0", "r1"); + + // FIXME: causes crash?! (if not at first line of gpmain()) + buildgammatab(gindex); + buildgammatab2(ARRAYSIZE(scrGamma) - 1); + + Init(); + + // ConfigRead(); + + //if () + //{ + // ConfigWrite(); + //} + + //ConfigMenu(); + //ConfigWrite(); + + // fixme - use get function + + //currentsurf=GAME_SURFACE; + //GpSurfaceFlip(&LCDbuffer[(int)currentsurf]); + +#ifndef GP32_GDB + int CPUSpeed = + atoi((const char *)menu[MENU_CPUSPEED].submenu[menu[MENU_CPUSPEED]. + index]); +#endif /*GP32_GDB */ + + //static char *argv[] = { "scummvm", NULL, NULL, NULL }; +// char *argv[] = { "scummvm", (char*)menu[MENU_MUSICDRV].submenu[menu[MENU_MUSICDRV].index]}; +// static int argc = 4; + + // Game Testing... + //int argc = 2; + //int argc = 4; char *argv[] = { "scummvm", "-enull", "-pgp:\\gpmm\\scummvm\\sky\\", "sky" }; + int argc = 4; + char *argv[] = { "scummvm", "-enull", "", "" }; + + while (1) { + // Only set the CPU speed if the GDB Stub is NOT needed. + // No point calling ClearScreen(); as we want to see any odd stuff. +#ifndef GP32_GDB + gpCPUSpeed(CPUSpeed); + ClearScreen(); +#endif /*GP32_GDB */ + + //FadeToWhite(200); + //exit(scummvm_main(argc, argv)); + ////////////////cast_argv = f(const_cast<double&>(d)); + //////////////char* argv_; + ////////////// argv_ = const_cast<*char*>(argv); + scummvm_main(argc, argv); + } } |