libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-02-21 19:51:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
scummvm/backends/gp32/gp32.cpp
Eugene Sandulenko b36677af71 Update FSF address. Eek. Actually that took place on May 1, 2005 
svn-id: r19142
2005-10-18 01:30:26 +00:00

3222 lines
80 KiB
C++
Raw Blame History

/* ScummVM - Scumm Interpreter
* Copyright (C) 2001 Ludvig Strigeus
* 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
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 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
void GpSetPaletteEntry(u8 i, u8 r, u8 g, u8 b);
// 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];
FILE *fstderr, *fstdout, *fstdin;
/****************************************************************
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;
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;
}
if (start < _paletteDirtyStart)
_paletteDirtyStart = start;
if (start + num > _paletteDirtyEnd)
_paletteDirtyEnd = start + num;
}
// 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, int overlayScale) {
/*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));
if (_dirty_checksums)
free(_dirty_checksums);
_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) {
if (_forceFull)
return;
if (_num_dirty_rects == NUM_DIRTY_RECT)
_forceFull = true;
else {
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;
}
// 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;
}
r->x = x;
r->y = y;
r->w = w;
r->h = h;
}
}
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;
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) {
// 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;
}
s1 %= BASE;
s2 %= BASE;
/* output the checksum for this block */
*sums++ = (s2 << 16) + s1;
}
}
void OSystem_GP32::add_dirty_rgn_auto(const byte *buf) {
assert(((uint32) buf & 3) == 0);
/* generate a table of the checksums */
mk_checksums(buf);
if (!cksum_valid) {
_forceFull = true;
cksum_valid = true;
}
/* 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 */
if (!_forceFull) {
int x, y, w;
uint32 *ck = _dirty_checksums;
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;
do {
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);
if (_forceFull)
goto get_out;
}
}
}
} else {
get_out:;
/* Copy old checksums to new */
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) {
if (_screen == NULL)
return;
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 (w <= 0 || h <= 0)
return;
cksum_valid = false;
add_dirty_rect(x, y, w, h);
}
/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
if (_mouseDrawn)
undraw_mouse();
byte *dst = (byte *) _screen->pixels + y * _screenWidth + x;
do {
memcpy(dst, buf, w);
dst += _screenWidth;
buf += pitch;
} while (--h);
}
gpSurface *gpCreateRGBSurface(Uint32 flags, int width, int height, int depth,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) {
gpSurface *surf = (gpSurface *) malloc(sizeof(gpSurface));
surf->format = (gpPixelFormat *) malloc(sizeof(gpPixelFormat));
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;
return surf;
}
gpSurface *gpSetVideoMode(int width, int height, int bpp, Uint32 flags) {
return gpCreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0);
}
void gpFreeSurface(gpSurface *surface) {
// implement
}
gpSurface *gpCreateRGBSurfaceFrom(void *pixels,
int width, int height, int depth, int pitch,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) {
// FIXME dont reuse code
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;
return surf;
}
int gpFillRect(gpSurface *dst, gpRect *dstrect, Uint32 color) {
// FIXME: implement
return 0;
}
int mcshake = 0;
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
}
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;
}
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;
}
rects++;
} else
error("blitting surface with wrong depth (%d)",
screen->format->BitsPerPixel);
// eh? works also when rects++ is here??
}
//#define gpBlitSurface gpUpperBlit
int gpBlitSurface(gpSurface *screen, gpRect *rects, gpSurface *dst, gpRect *dstrect) {
// FIXME? role??
//gpUpdateRects(screen, 1, rects); //ph0x! _hwscreen
return 0;
}
int gpSetColors(gpSurface *surface, gpColor *colors, int firstcolor, int ncolors) {
float rr, gg, bb;
gpColor colors2[256];
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, &LCDbuffer[GAME_SURFACE], 0, 0, 320, 240, 0); //black border
_forceFull = true;
_mode_flags = DF_WANT_RECT_OPTIM | DF_UPDATE_EXPAND_1_PIXEL;
_tmpscreen = NULL;
TMP_SCREEN_WIDTH = (_screenWidth + 3);
switch (_mode) {
case GFX_NORMAL:
//???????
//normal_mode:;
_scaleFactor = 1;
_scaler_proc = Normal1x;
break;
default:
error("Unknown graphics mode");
_scaleFactor = 1;
_scaler_proc = NULL;
}
//
// Create the surface that contains the 8 bit game data
//
_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
//
_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 (_hwscreen->format->Rmask == 0x7C00)
InitScalers(555);
else
InitScalers(565);
*/
//InitScalers(555); // ph0x fixme?
//ph0x fixme - tmpscreen needed?
// Need some extra bytes around when using 2xSaI
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 = 15;
km.last_time = 0;
}
void OSystem_GP32::unload_gfx_mode() {
if (_screen) {
gpFreeSurface(_screen);
_screen = NULL;
}
if (_hwscreen) {
gpFreeSurface(_hwscreen);
_hwscreen = NULL;
}
if (_tmpscreen) {
free((uint16 *) _tmpscreen->pixels);
gpFreeSurface(_tmpscreen);
_tmpscreen = NULL;
}
}
#include "common/util.h"
void OSystem_GP32::draw_mouse() {
if (!_overlayVisible) {
if (_mouseDrawn || !_mouseVisible)
return;
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;
// 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;
// Draw the mouse cursor; backup the covered area in "bak"
///if (gpLockSurface(_screen) == -1)
/// error("gpLockSurface failed: %s.\n", gpGetError());
// 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--;
}
src += _mouseCurState.w - w;
bak += MAX_MOUSE_W - w;
dst += _screenWidth - w;
h--;
}
///gpUnlockSurface(_screen);
// Finally, set the flag to indicate the mouse has been drawn
_mouseDrawn = true;
}
if (_mouseDrawn || !_mouseVisible)
return;
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 *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) {
w += x;
src -= x;
x = 0;
}
if (y < 0) {
h += y;
src -= y * _mouseCurState.w;
y = 0;
}
// Quick check to see if anything has to be drawn at all
if (w <= 0 || h <= 0)
return;
if (w > _screenWidth - x)
w = _screenWidth - x;
if (h > _screenHeight - y)
h = _screenHeight - y;
// 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;
// Draw the mouse cursor; backup the covered area in "bak"
///if (gpLockSurface(_tmpscreen) == -1)
/// error("gpLockSurface failed: %s.\n", gpGetError());
// as dirty
add_dirty_rect(x, y, w, h);
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 =
RGB_TO_16(_currentPalette[color].r,
_currentPalette[color].g,
_currentPalette[color].b);
dst++;
width--;
}
src += _mouseCurState.w - w;
bak += MAX_MOUSE_W - w;
dst += TMP_SCREEN_WIDTH - w;
h--;
}
///gpUnlockSurface(_tmpscreen);
// Finally, set the flag to indicate the mouse has been drawn
_mouseDrawn = true;
}
void OSystem_GP32::undraw_mouse() {
//return; //fixme!
if (!_overlayVisible) {
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);
}
if (!_mouseDrawn)
return;
_mouseDrawn = false;
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 *) _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);
}
char *gpGetError(void) {
// FIXME: implement
return NULL;
}
/////////////////////////////////////////////////////////////////////////////
//
// 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) {
if (_mouseVisible == visible)
return visible;
bool last = _mouseVisible;
_mouseVisible = visible;
if (visible)
draw_mouse();
else
undraw_mouse();
return last;
}
// Set the position of the mouse cursor
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
undraw_mouse();
}
}
// 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, 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);
}
// Shaking is used in SCUMM. Set current shake position.
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();
}
// Delay for a specified amount of milliseconds
void OSystem_GP32::delayMillis(uint msecs) {
int n = GpTickCountGet();
while ((GpTickCountGet() - n) < msecs);
}
// Get the next event.
// 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) {
#define EVENT_COUNT 2 // >=1
//#define MOUSE_MIPS 2 // bg updates wrong if >1 ??
#define MOUSE_MIPS 1 // bg updates wrong if >1 ??
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;
}
if (key == GPC_VK_NONE) {
lastevent = lastkey = 0;
return false;
}
if (key == lastkey) {
eventcount--;
if (eventcount)
return false;
}
eventcount = EVENT_COUNT;
event.type = EVENT_KEYDOWN;
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;
}
if (key == lastkey)
return false;
if (skindex > 0)
skindex--;
event.kbd.keycode = event.kbd.ascii = shortkey[skindex];
lastevent = event.type;
lastkey = key;
return true;
}
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_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 (_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) {
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) {
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_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_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;
set_mouse_pos(event.mouse.x, event.mouse.y);
}
/////////////////////////////////////////////////////////////////////////////
//
// 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;
}
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 (gpLockSurface(_screen) == -1)
/// error("gpLockSurface failed: %s.\n", gpGetError());
memcpy(buf, _screen->pixels, _screenWidth * _screenHeight);
///gpUnlockSurface(_screen);
}
void OSystem_GP32::hotswap_gfx_mode() {
/* We allocate a screen sized bitmap which contains a "backup"
* 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);
get_screen_image(bak_mem);
unload_gfx_mode();
load_gfx_mode();
// reset palette
gpSetColors(_screen, _currentPalette, 0, 256);
// blit image
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;
//}
void OSystem_GP32::setWindowCaption(const char *caption) {
//gGameName = caption; // Would like to return game here like DC port. - DJWillis
}
// CDROM Code - All returns false as the GP32 has no CDROM ;-)
bool OSystem_GP32::openCD(int drive) {
return false;
}
bool OSystem_GP32::pollCD() {
return false;
}
void OSystem_GP32::playCD(int track, int num_loops, int start_frame, int duration) {
}
void OSystem_GP32::stopCD() {
}
void OSystem_GP32::updateCD() {
}
// End CDROM Code.
// Add a new callback timer
// 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) {
}
void OSystem_GP32::unlockMutex(MutexRef) {
}
void OSystem_GP32::deleteMutex(MutexRef) {
}
// Quit
void OSystem_GP32::quit() {
printf("Quitting...");
exit(0);
}
// Overlay
void OSystem_GP32::showOverlay() {
// hide the mouse
undraw_mouse();
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() {
// hide the mouse
undraw_mouse();
GpGraphicModeSet(8, NULL); //ph0x
GpRectFill(NULL, &LCDbuffer[GAME_SURFACE], 0, 0, 320, 240, 0); //black border
_overlayVisible = false;
_forceFull = true;
}
void OSystem_GP32::clearOverlay() {
if (!_overlayVisible)
return;
// hide the mouse
undraw_mouse();
// Clear the overlay by making the game screen "look through" everywhere.
gpRect src, dst;
src.x = src.y = 0;
dst.x = dst.y = 1;
src.w = dst.w = _screenWidth;
src.h = dst.h = _screenHeight;
if (gpBlitSurface(_screen, &src, _tmpscreen, &dst) != 0) //FIXME
error("gpBlitSurface failed: %s", gpGetError());
_forceFull = true;
}
void OSystem_GP32::grabOverlay(int16 *buf, int pitch) {
if (!_overlayVisible)
return;
if (_tmpscreen == NULL)
return;
// hide the mouse
undraw_mouse();
///if (gpLockSurface(_tmpscreen) == -1)
/// error("gpLockSurface failed: %s.\n", gpGetError());
int16 *src = (int16 *) _tmpscreen->pixels + TMP_SCREEN_WIDTH + 1;
int h = _screenHeight;
do {
memcpy(buf, src, _screenWidth * 2);
src += TMP_SCREEN_WIDTH;
buf += pitch;
} while (--h);
///gpUnlockSurface(_tmpscreen);
}
void OSystem_GP32::copyRectToOverlay(const int16 * buf, int pitch, int x,
int y, int w, int h) {
if (!_overlayVisible)
return;
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 (w <= 0 || h <= 0)
return;
// Mark the modified region as dirty
cksum_valid = false;
add_dirty_rect(x, y, w, h);
/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
undraw_mouse();
///if (gpLockSurface(_tmpscreen) == -1)
/// error("gpLockSurface failed: %s.\n", gpGetError());
int16 *dst =
(int16 *) _tmpscreen->pixels + (y + 1) * TMP_SCREEN_WIDTH + (x +
1);
do {
memcpy(dst, buf, w * 2);
dst += TMP_SCREEN_WIDTH;
buf += pitch;
} while (--h);
///gpUnlockSurface(_tmpscreen);
}
void OSystem_GP32::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;
}
//#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;
}
// 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;
}
}
bool OSystem_GP32::hasFeature(Feature f) {
return false;
(f == kFeatureFullscreenMode) || (f == kFeatureAspectRatioCorrection);
// ||
// (f == kFeatureAutoComputeDirtyRects);
}
bool OSystem_GP32::getFeatureState(Feature f) {
switch (f) {
case kFeatureFullscreenMode:
return _full_screen;
case kFeatureAspectRatioCorrection:
return _adjustAspectRatio;
case kFeatureAutoComputeDirtyRects:
return _mode_flags & DF_WANT_RECT_OPTIM;
default:
return false;
}
}
void OSystem_GP32::setFullscreenMode(bool enable) {
Common::StackLock lock(_graphicsMutex);
if (_full_screen != enable) {
assert(_hwscreen != 0);
_full_screen ^= true;
undraw_mouse();
//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;
}
////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]; // ?
va_list marker;
if (busy)
return 0;
busy = true;
va_start(marker, fmt);
vsnprintf(s, 1024, fmt, marker);
va_end(marker);
#ifdef GPDEBUG
//dprintf("mem: %d ", gm_availablesize());
dprintf(s);
if (s[strlen(s) - 1] != '\n')
dprintf("\n");
//if (s[0]!='>') return r;
#endif
fprintf(stdout, s);
// print to lcd
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);
}
busy = false;
return 0;
}
int gpfprintf(FILE *stream, const char *fmt, ...) {
char s[256];
va_list marker;
va_start(marker, fmt);
vsnprintf(s, 256, fmt, marker);
va_end(marker);
return fwrite(s, 1, strlen(s), stream);
}
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;
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') {
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");
if (!f)
error("%s: cannot crate F_HANDLE", __FUNCTION__);
if (err) {
//printf("IOerr %d", err);
return NULL;
} else
return f;
}
int gpfclose(FILE *f) {
if (!f) {
//warning("closing null file");
return 1;
}
if (*(u32 *)((char *)f - sizeof(u32)) == 0x4321) {
debug(0, "Double closing", __FUNCTION__);
return 1;
} // 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;
}
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;
}
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);
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?
}
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) {
//warning("fixme: %s", __FUNCTION__);
}
int gpfeof(FILE *f) { //fixme!
return ftell(f) >= XFILE(f).size;
}
char *gpfgets(char *s, int n, FILE *f) {
int i = 0;
while (!feof(f) && i < n) {
fread(&s[i], 1, 1, f);
if (s[i] == '\n') {
s[i + 1] = 0;
return s;
}
i++;
}
if (feof(f))
return NULL;
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;
}
/*
* GP32 Memory managment.
*/
void *gpmalloc(size_t size) {
u32 np;
u32 *up;
np = (u32) gm_malloc(size + sizeof(u32));
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 gpfree(void *block) {
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);
}
/*
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 *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;
}
void gpdeinit() {
fclose(fstdin);
fclose(fstdout);
fclose(fstderr);
}
void gpexit(int code) {
switchsurf(DEBUG_SURFACE);
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);
}
}
/****************************************************************
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;
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);
}
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++;
}
//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);
}
}
/****************************************************************
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);
//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();
}
/****************************************************************
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);
//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(COLOUR_8BIT_MODE, NULL);
// Set the current buffer
nflip = 0;
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];
}
}
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[]);
void GpMain(void *arg) {
#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);
}
}
Reference in New Issue View Git Blame Copy Permalink