libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-01-05 09:10:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
e46ba2f29f
scummvm/backends/gp32/gp32.cpp

1566 lines
38 KiB
C++
Raw Blame History

/* ScummVM - Scumm Interpreter
* Copyright (C) 2001 Ludvig Strigeus
* Copyright (C) 2001/2002 The ScummVM project
* Copyright (C) 2002 ph0x (GP32 port)
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//#define GPDEBUG //uncomment for debug messages (use DarkFader's emudebug.exe)
#include "gp32.h"
#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
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) {
const byte *b = colors;
uint i;
SDL_Color *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
void OSystem_GP32::initSize(uint w, uint h) {
// 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));
unload_gfx_mode();
load_gfx_mode();
}
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 {
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
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;
}
}
#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;
/* 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;
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);
/* output the checksum for this block */
*sums++=a+b;
}
}
#undef DOLINE
#undef ROL
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::copy_rect(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();
///if (SDL_LockSurface(_screen) == -1)
/// error("SDL_LockSurface failed: %s.\n", SDL_GetError());
byte *dst = (byte *)_screen->pixels + y * _screenWidth + x;
do {
memcpy(dst, buf, w);
dst += _screenWidth;
buf += pitch;
} while (--h);
///SDL_UnlockSurface(_screen);
}
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));
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);
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;
}
SDL_Surface *SDL_SetVideoMode
(int width, int height, int bpp, Uint32 flags) {
return SDL_CreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0);
}
void SDL_FreeSurface(SDL_Surface *surface) {
// implement
}
SDL_Surface *SDL_CreateRGBSurfaceFrom(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));
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
return 0;
}
void SDL_UpdateRects(SDL_Surface *screen, int numrects, SDL_Rect *rects) {
// FIXME dont duplicate code :)
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;
}
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;
}
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 SDL_BlitSurface SDL_UpperBlit
int SDL_BlitSurface(SDL_Surface *screen, SDL_Rect *rects,
SDL_Surface *dst, SDL_Rect *dstrect) {
// FIXME? role??
//SDL_UpdateRects(screen, 1, rects); //ph0x! sdl_hwscreen
return 0;
}
int SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors) {
if (currsurface == DEBUG_SURFACE) return 1;
GpPaletteEntryChangeEx(firstcolor, ncolors, (GP_LOGPALENTRY*)colors, 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--)
copy_rect((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++)
copy_rect((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--)
copy_rect((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++)
copy_rect((byte *)_screen->pixels + x - dx, _screenWidth, x, 0, 1, height);
}
} else {
// free movement
// not necessary for now
}
}
void OSystem_GP32::load_gfx_mode() {
GpRectFill(NULL,&gpDraw[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;
TMP_SCREEN_WIDTH = (_screenWidth + 3);
switch(_mode) {
case GFX_NORMAL:
normal_mode:;
_scaleFactor = 1;
_scaler_proc = Normal1x;
break;
default:
error("unknown gfx mode");
_scaleFactor = 1;
_scaler_proc = NULL;
}
//
// Create the surface that contains the 8 bit game data
//
_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _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");
//
// 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)
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));
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");
// 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.last_time = 0;
}
void OSystem_GP32::unload_gfx_mode() {
if (_screen) {
SDL_FreeSurface(_screen);
_screen = NULL;
}
if (sdl_hwscreen) {
SDL_FreeSurface(sdl_hwscreen);
sdl_hwscreen = NULL;
}
if (sdl_tmpscreen) {
free((uint16*)sdl_tmpscreen->pixels);
SDL_FreeSurface(sdl_tmpscreen);
sdl_tmpscreen = NULL;
}
}
#include "common/util.h"
void OSystem_GP32::draw_mouse() {
if (!_overlay_visible) {
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
// 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;
// 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"
///if (SDL_LockSurface(_screen) == -1)
/// error("SDL_LockSurface failed: %s.\n", SDL_GetError());
// Mark 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 != 0xFF) // 0xFF = transparent, don't draw
*dst = color;
dst++;
width--;
}
src += _mouse_cur_state.w - w;
bak += MAX_MOUSE_W - w;
dst += _screenWidth - w;
h--;
}
///SDL_UnlockSurface(_screen);
// 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;
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
// 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;
}
// 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.
_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"
///if (SDL_LockSurface(sdl_tmpscreen) == -1)
/// error("SDL_LockSurface failed: %s.\n", SDL_GetError());
// Mark as dirty
add_dirty_rect(x, y, w, h);
dst = (uint16 *)sdl_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++;
width--;
}
src += _mouse_cur_state.w - w;
bak += MAX_MOUSE_W - w;
dst += TMP_SCREEN_WIDTH - w;
h--;
}
///SDL_UnlockSurface(sdl_tmpscreen);
// Finally, set the flag to indicate the mouse has been drawn
_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());
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];
}
}
add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
///SDL_UnlockSurface(_screen);
}
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;
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) {
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
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;
}
// Either show or hide the mouse cursor
bool OSystem_GP32::show_mouse(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 != _mouse_cur_state.x || y != _mouse_cur_state.y) {
_mouse_cur_state.x = x;
_mouse_cur_state.y = y;
mx=x; //ph0x fixme
my=y; //ph0x fixme
undraw_mouse();
}
}
void OSystem_GP32::warp_mouse(int x, int y) {
set_mouse_pos(x, y);
}
// Set the bitmap that's used when drawing the cursor.
void OSystem_GP32::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
_mouse_cur_state.w = w;
_mouse_cur_state.h = h;
_mouseHotspotX = hotspot_x;
_mouseHotspotY = hotspot_y;
_mouseData = (byte*)buf;
undraw_mouse();
}
// Shaking is used in SCUMM. Set current shake position.
void OSystem_GP32::set_shake_pos(int shake_pos) {
_newShakePos = shake_pos;
}
// Get the number of milliseconds since the program was started.
uint32 OSystem_GP32::get_msecs() {
return GpTickCountGet();
}
// Delay for a specified amount of milliseconds
void OSystem_GP32::delay_msecs(uint msecs) {
int n = GpTickCountGet();
while ( ( GpTickCountGet() - n ) < msecs) ;
}
// Get the next event.
// Returns true if an event was retrieved.
bool OSystem_GP32::poll_event(Event *event) { // fixme: make more user-friendly :)
#define EVENT_COUNT 2 // >=1
#define MOUSE_MIPS 1 // bg updates wrong if >1 ??
static int oldkey, eventcount=EVENT_COUNT, lastevent=0;
int key;
key=GpKeyGet();
if (key == GPC_VK_NONE) {
if (lastevent==EVENT_LBUTTONDOWN) {
lastevent=0;
event->event_code = EVENT_LBUTTONUP;
return true;
}
return false;
}
if (key == oldkey) {
eventcount--;
if (eventcount) return false;
}
oldkey=key;
eventcount=EVENT_COUNT;
event->event_code = EVENT_KEYDOWN;
if (key & GPC_VK_FL && key & GPC_VK_FR) { // L+R = save state
printf("Saving game, please wait...");
//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 & 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;
}
if (key & GPC_VK_START) { // START = menu
event->kbd.keycode = 319;
event->kbd.ascii = 319;
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;
return true;
}
if (key & GPC_VK_FA) {
lastevent=EVENT_LBUTTONDOWN;
event->event_code = EVENT_LBUTTONDOWN;
return true;
}
if (key & GPC_VK_FB) {
lastevent=EVENT_RBUTTONDOWN;
event->event_code = 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>199) my=199;
}
event->event_code = 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);
}
// 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;
}
void OSystem_GP32::clearSoundCallback() {
//_sound_proc = NULL;
//_sound_proc_param = NULL;
}
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);
///SDL_UnlockSurface(_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
SDL_SetColors(_screen, _currentPalette, 0, 256);
// blit image
copy_rect(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;
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;
case PROP_SET_GFX_MODE:
if (value->gfx_mode >= 7)
return 0;
_mode = value->gfx_mode;
hotswap_gfx_mode();
return 1;
case PROP_GET_SAMPLE_RATE:
///return SAMPLES_PER_SEC; //ph0x fixme
return 22050;
}
return 0;
}
// Poll cdrom status
// Returns true if cd audio is playing
bool OSystem_GP32::poll_cdrom() { return false; }
// Play cdrom audio track
void OSystem_GP32::play_cdrom(int track, int num_loops, int start_frame, int duration) { }
// Stop cdrom audio track
void OSystem_GP32::stop_cdrom() { }
// Update cdrom audio status
void OSystem_GP32::update_cdrom() { }
// Add a new callback timer
void OSystem_GP32::set_timer(TimerProc callback, int timer) { }
// Mutex handling
OSystem::MutexRef OSystem_GP32::createMutex() {
return NULL;
}
void OSystem_GP32::lockMutex(MutexRef mutex) { }
void OSystem_GP32::unlockMutex(MutexRef mutex) { }
void OSystem_GP32::deleteMutex(MutexRef mutex) { }
// Quit
void gphalt(int);
void OSystem_GP32::quit() {
exit(0);
}
// Overlay
void OSystem_GP32::show_overlay() {
// 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;
clear_overlay();
}
void OSystem_GP32::hide_overlay() {
// hide the mouse
undraw_mouse();
GpGraphicModeSet(8, NULL); //ph0x
GpRectFill(NULL,&gpDraw[GAME_SURFACE], 0, 200, 320, 40, 0); //black border
_overlay_visible = false;
_forceFull = true;
}
void OSystem_GP32::clear_overlay() {
if (!_overlay_visible)
return;
// hide the mouse
undraw_mouse();
// Clear the overlay by making the game screen "look through" everywhere.
SDL_Rect 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());
_forceFull = true;
}
void OSystem_GP32::grab_overlay(int16 *buf, int pitch) {
if (!_overlay_visible)
return;
if (sdl_tmpscreen == NULL)
return;
// hide the mouse
undraw_mouse();
///if (SDL_LockSurface(sdl_tmpscreen) == -1)
/// error("SDL_LockSurface failed: %s.\n", SDL_GetError());
int16 *src = (int16 *)sdl_tmpscreen->pixels + TMP_SCREEN_WIDTH + 1;
int h = _screenHeight;
do {
memcpy(buf, src, _screenWidth*2);
src += TMP_SCREEN_WIDTH;
buf += pitch;
} while (--h);
///SDL_UnlockSurface(sdl_tmpscreen);
}
void OSystem_GP32::copy_rect_overlay(const int16 *buf, int pitch, int x, int y, int w, int h) {
if (!_overlay_visible)
return;
if (sdl_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 (SDL_LockSurface(sdl_tmpscreen) == -1)
/// error("SDL_LockSurface failed: %s.\n", SDL_GetError());
int16 *dst = (int16 *)sdl_tmpscreen->pixels + (y+1) * TMP_SCREEN_WIDTH + (x+1);
do {
memcpy(dst, buf, w*2);
dst += TMP_SCREEN_WIDTH;
buf += pitch;
} while (--h);
///SDL_UnlockSurface(sdl_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);
// allocate the dirty rect storage
syst->_mouseBackup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
return syst;
}
OSystem *OSystem_GP32_create(int gfx_mode, bool full_screen) {
return OSystem_GP32::create(gfx_mode, full_screen); // fullscreen
}
//////////////////////////////////////////////////
// GP32 stuff
//////////////////////////////////////////////////
extern "C" int write(int fd, void *p, size_t n);
int write(int fd, void *p, size_t n) { return 0; } //ph0x hack!
// 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 );
}
void switchsurf(int surf) {
GPLCDINFO lcd;
GpLcdInfoGet(&lcd);
if (surf == DEBUG_SURFACE) {
if (lcd.lcd_global.U8_lcd.bpp == 16)
GpGraphicModeSet(8, NULL);
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]);
}
}
}
int gpprintf(const char *fmt, ...) { //return 0; //fixme
static int y;
char s[1024]; // ?
int r;
va_list marker;
// combine
va_start(marker, fmt);
r = vsprintf(s, fmt, marker);
va_end(marker);
// print to console
#ifdef GPDEBUG
//dprintf("mem: %d ", gm_availablesize());
dprintf(s);
if (s[strlen(s)-1] != '\n') dprintf("\n");
//if (s[0]!='>') return r;
#endif
// 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);
}
return r;
}
int gpfprintf(FILE *stream, const char *fmt, ...) {
//printf(fmt, "fixme");
}
FILE *gpfopen(const char *filename, const char *mode) {
//FIXME:
// - allocation ?
// - mode
// - malloc -> new
ulong m;
FILE *f = (FILE*)malloc(sizeof(FILE) + sizeof(ulong));
//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') {
//printf("open if as W");
*(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 (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;
}
int gpfclose(FILE *stream) {
if (*(u32*)((char*)stream-sizeof(u32)) == 0x4321) {
debug(0, "double closing", __FUNCTION__);
return 1;
} // return 1 ??
ERR_CODE err = GpFileClose(*stream);
free(stream);
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 *stream) {
ERR_CODE err=GpFileWrite(*stream, ptr, size*n); //fixme size*n?
//printf("writing to file");
return err;
}
void gpclearerr(FILE *stream) {
//error("fixme: %s", __FUNCTION__);
}
int gpfeof(FILE *stream) { //fixme!
return ftell(stream) >= *(ulong*)(stream+1);
}
char *gpfgets(char *s, int n, FILE *f) {
int err, 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;
}
int gpfflush(FILE *stream) { return 0;}
void *gpmalloc(size_t size) {
void *p = gm_malloc(size+sizeof(u32)); // gm_zi_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;
}
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));
}
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 *strSource) {
char *buffer;
buffer = (char *)malloc(strlen(strSource) + 1);
if (buffer)
strcpy(buffer, strSource);
return buffer;
}
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);
printf("Your GP32 will now restart...");
gpdeinit();
GpAppExit();
}
//#include <string.h>
#include "common/gamedetector.h"
VersionSettings* menu() {
const VersionSettings *v = version_settings;
VersionSettings* games[30];
int n=0;
/*GpSetPaletteEntry ( 0, 0,0,0 );
GpSetPaletteEntry ( 1, 255,0,0 );
GpSetPaletteEntry ( 2, 255,255,255 );*/
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);
}
v++;
}
int i, key, fg, bg, choice=0, y=0;
//GpRectFill(NULL,&gpDraw[currsurface], 0, 0, 320, 200, 2);
GpTextOut(NULL, &gpDraw[currsurface], 0, y, "ScummVM (GP32 port by ph0x)", 255); y+=ENGFONT_H;
if (!n) {
GpTextOut(NULL, &gpDraw[currsurface], 0, y, "No games found! put game data in gp:\\", 255); y+=ENGFONT_H;
while (1);
}
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);
}
int gpinit() {
ERR_CODE err;
//GpKeyInit();
GpFatInit();
GpRelativePathSet("gp:\\gpmm");
// 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);
// fixme - use get function
currsurface=DEBUG_SURFACE;
GpSurfaceSet(&gpDraw[currsurface]);
GpLcdEnable();
#ifdef GPDEBUG
printf(">waiting for debugger...");
InitDebug();
#endif
printf(">Running ScummVM");
}
extern "C" void GpMain (void * arg); // hack
void GpMain (void * arg) {
gpinit();
// fixme - use get function
currsurface=GAME_SURFACE;
GpSurfaceFlip(&gpDraw[currsurface]);
char *argv[] = { "scummvm", /*(char*)menu()->filename*/ NULL };
int argc = 1;
extern int main(int argc, char *argv[]);
main(argc, argv);
error("returned from main ?!");
}
Reference in New Issue View Git Blame Copy Permalink