thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
scummvm/sdl.cpp
Ludvig Strigeus 3a4fa636ee code cleanup - prepares for simon inclusion 
svn-id: r3910
2002-04-12 10:34:46 +00:00

1243 lines
28 KiB
C++
Raw Blame History

/* ScummVM - Scumm Interpreter
* Copyright (C) 2001 Ludvig Strigeus
* Copyright (C) 2001/2002 The ScummVM project
*
* 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.
*
* $Header$
*
*/
#define NEED_SDL_HEADERS
#include "stdafx.h"
#include "scumm.h"
#include "gui.h"
#include "SDL_thread.h"
#include "gameDetector.h"
#include "cdmusic.h"
#include "mp3_cd.h"
static unsigned int scale;
/* FIXME: Global variable names should be prepended with g_
* Only member variables should have a _ in front of the name. */
Scumm *g_scumm;
ScummDebugger debugger;
Gui gui;
OSystem _system;
GameDetector detector;
SoundEngine sound;
SOUND_DRIVER_TYPE snd_driv;
static SDL_Surface *screen;
static SDL_CD *cdrom;
/* For 2xSAI */
static SDL_Surface *sdl_hwscreen;
static SDL_Surface *sdl_tmpscreen;
int Init_2xSaI(uint32 BitFormat);
void _2xSaI(uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr, uint8 *dstPtr,
uint32 dstPitch, int width, int height);
void Super2xSaI(uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr,
uint8 *dstPtr, uint32 dstPitch, int width, int height);
void SuperEagle(uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr,
uint8 *dstPtr, uint32 dstPitch, int width, int height);
static int current_shake_pos;
void resetCursor(void)
{
SDL_ShowCursor(SDL_ENABLE);
}
void updateScreen(Scumm *s);
void updatePalette(Scumm *s)
{
SDL_Color colors[256];
int first = s->_palDirtyMin;
int num = s->_palDirtyMax - first + 1;
int i;
byte *data = s->_currentPalette;
data += first * 3;
for (i = 0; i < num; i++, data += 3) {
colors[i].r = data[0];
colors[i].g = data[1];
colors[i].b = data[2];
colors[i].unused = 0;
}
SDL_SetColors(screen, colors, first, num);
s->_palDirtyMax = -1;
s->_palDirtyMin = 0x3E8;
}
int mapKey(int key, byte mod)
{
if (key >= SDLK_F1 && key <= SDLK_F9) {
return key - SDLK_F1 + 315;
} else if (key >= 'a' && key <= 'z' && mod & KMOD_SHIFT) {
key &= ~0x20;
} else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO)
return 0;
return key;
}
void waitForTimer(Scumm *s, int msec_delay)
{
SDL_Event event;
uint32 start_time;
if (s->_fastMode & 2)
msec_delay = 0;
else if (s->_fastMode & 1)
msec_delay = 10;
start_time = SDL_GetTicks();
do {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
s->_keyPressed = mapKey(event.key.keysym.sym, event.key.keysym.mod);
if (event.key.keysym.sym >= '0' && event.key.keysym.sym <= '9') {
s->_saveLoadSlot = event.key.keysym.sym - '0';
if (event.key.keysym.mod & KMOD_SHIFT) {
sprintf(s->_saveLoadName, "Quicksave %d", s->_saveLoadSlot);
s->_saveLoadFlag = 1;
} else if (event.key.keysym.mod & KMOD_CTRL)
s->_saveLoadFlag = 2;
s->_saveLoadCompatible = false;
} else if (event.key.keysym.sym == 'z'
&& event.key.keysym.mod & KMOD_CTRL) {
exit(1);
} else if (event.key.keysym.sym == 'f'
&& event.key.keysym.mod & KMOD_CTRL) {
s->_fastMode ^= 1;
} else if (event.key.keysym.sym == 'g'
&& event.key.keysym.mod & KMOD_CTRL) {
s->_fastMode ^= 2;
} else if (event.key.keysym.sym == 'd'
&& event.key.keysym.mod & KMOD_CTRL) {
debugger.attach(s);
} else if (event.key.keysym.sym == 's'
&& event.key.keysym.mod & KMOD_CTRL) {
s->resourceStats();
} else if (event.key.keysym.sym == SDLK_RETURN
&& event.key.keysym.mod & KMOD_ALT) {
if (!SDL_WM_ToggleFullScreen(screen))
warning("Full screen failed");
}
#if defined(__APPLE__) || defined(MACOS)
if (event.key.keysym.sym == 'q' && event.key.keysym.mod & KMOD_LMETA) {
exit(1);
}
#endif
break;
case SDL_MOUSEMOTION:{
int newx, newy;
if (scale == 3) {
newx = event.motion.x / 3;
newy = event.motion.y / 3;
} else if (scale == 2) {
newx = event.motion.x >> 1;
newy = event.motion.y >> 1;
} else {
newx = event.motion.x;
newy = event.motion.y;
}
if (newx != s->mouse.x || newy != s->mouse.y) {
s->mouse.x = newx;
s->mouse.y = newy;
s->drawMouse();
updateScreen(s);
}
break;
}
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT)
s->_leftBtnPressed |= msClicked | msDown;
else if (event.button.button == SDL_BUTTON_RIGHT)
s->_rightBtnPressed |= msClicked | msDown;
break;
case SDL_MOUSEBUTTONUP:
if (event.button.button == SDL_BUTTON_LEFT)
s->_leftBtnPressed &= ~msDown;
else if (event.button.button == SDL_BUTTON_RIGHT)
s->_rightBtnPressed &= ~msDown;
break;
case SDL_QUIT:
exit(1);
break;
}
}
cd_music_loop(); // Loop CD Music if necessary
if (SDL_GetTicks() >= start_time + msec_delay)
break;
SDL_Delay(10);
} while (1);
}
#define MAX_DIRTY_RECTS 40
SDL_Rect dirtyRects[MAX_DIRTY_RECTS];
int numDirtyRects;
bool fullRedraw;
int old_mouse_x, old_mouse_y;
int old_mouse_h, old_mouse_w;
bool has_mouse, hide_mouse;
#define BAK_WIDTH 40
#define BAK_HEIGHT 40
byte old_backup[BAK_WIDTH * BAK_HEIGHT * 2];
void addDirtyRect(int x, int y, int w, int h)
{
SDL_Rect *r;
if (numDirtyRects == MAX_DIRTY_RECTS)
fullRedraw = true;
else if (!fullRedraw) {
r = &dirtyRects[numDirtyRects++];
if (scale == 3) {
r->x = x * 3;
r->y = y * 3;
r->w = w * 3;
r->h = h * 3;
} else if (scale == 2) {
r->x = x * 2;
r->y = y * 2;
r->w = w * 2;
r->h = h * 2;
} else {
r->x = x;
r->y = y;
r->w = w;
r->h = h;
}
}
}
void addDirtyRectClipped(int x, int y, int w, int h)
{
if (x < 0) {
w += x;
x = 0;
}
if (y < 0) {
h += y;
y = 0;
}
if (w >= 320 - x)
w = 320 - x;
if (h >= 200 - y)
h = 200 - y;
if (w > 0 && h > 0)
addDirtyRect(x, y, w, h);
}
#define MAX(a,b) (((a)<(b)) ? (b) : (a))
#define MIN(a,b) (((a)>(b)) ? (b) : (a))
void setShakePos(Scumm *s, int shake_pos)
{
int old_shake_pos = current_shake_pos;
int dirty_height, dirty_blackheight;
int dirty_top, dirty_blacktop;
if (shake_pos != old_shake_pos) {
current_shake_pos = shake_pos;
fullRedraw = true;
/* Old shake pos was current_shake_pos, new is shake_pos.
* Move the screen up or down to account for the change.
*/
SDL_Rect dstr = { 0, shake_pos*scale, 320*scale, 200*scale };
SDL_Rect srcr = { 0, old_shake_pos*scale, 320*scale, 200*scale };
SDL_BlitSurface(screen, &srcr, screen, &dstr);
/* Also adjust the mouse pointer backup Y coordinate.
* There is a minor mouse glitch when the mouse is moved
* at the blackness of the shake area, but it's hardly noticable */
old_mouse_y += shake_pos - old_shake_pos;
/* Refresh either the upper part of the screen,
* or the lower part */
if (shake_pos > old_shake_pos) {
dirty_height = MIN(shake_pos, 0) - MIN(old_shake_pos, 0);
dirty_top = -MIN(shake_pos, 0);
dirty_blackheight = MAX(shake_pos, 0) - MAX(old_shake_pos, 0);
dirty_blacktop = MAX(old_shake_pos, 0);
} else {
dirty_height = MAX(old_shake_pos, 0) - MAX(shake_pos, 0);
dirty_top = 200 - MAX(old_shake_pos, 0);
dirty_blackheight = MIN(old_shake_pos, 0) - MIN(shake_pos, 0);
dirty_blacktop = 200 + MIN(shake_pos, 0);
}
/* Fill the dirty area with blackness or the scumm image */
SDL_Rect blackrect = {0, dirty_blacktop*scale, 320*scale, dirty_blackheight*scale};
SDL_FillRect(screen, &blackrect, 0);
s->redrawLines(dirty_top, dirty_top + dirty_height);
}
}
/* Copy part of bitmap */
void blitToScreen(Scumm *s, byte *src, int x, int y, int w, int h)
{
byte *dst;
int i;
hide_mouse = true;
if (has_mouse) {
s->drawMouse();
}
/* Account for the shaking and do Y clipping */
y += current_shake_pos;
if (y < 0) {
h += y;
src -= y * 320;
y = 0;
}
if (h > 200 - y) {
h = 200 - y;
}
if (h <= 0)
return;
if (SDL_LockSurface(screen) == -1)
error("SDL_LockSurface failed: %s.\n", SDL_GetError());
if (scale == 3) {
dst = (byte *)screen->pixels + y * 960 * 3 + x * 3;
addDirtyRect(x, y, w, h);
#ifdef DEBUG_CODE
byte black = GetAsyncKeyState(VK_SHIFT) < 0 ? 0 : 0xFF;
do {
i = 0;
do {
dst[i * 3] = dst[i * 3 + 1] = dst[i * 3 + 2] = src[i] & black;
} while (++i != w);
memcpy(dst + 960, dst, w * 3);
memcpy(dst + 960 + 960, dst, w * 3);
dst += 960 * 3;
src += 320;
} while (--h);
#else
do {
i = 0;
do {
dst[i * 3] = dst[i * 3 + 1] = dst[i * 3 + 2] = src[i];
} while (++i != w);
memcpy(dst + 960, dst, w * 3);
memcpy(dst + 960 + 960, dst, w * 3);
dst += 960 * 3;
src += 320;
} while (--h);
#endif
} else if (scale == 2) {
dst = (byte *)screen->pixels + y * 640 * 2 + x * 2;
addDirtyRect(x, y, w, h);
#ifdef DEBUG_CODE
byte black = GetAsyncKeyState(VK_SHIFT) < 0 ? 0 : 0xFF;
do {
i = 0;
do {
dst[i * 2] = dst[i * 2 + 1] = src[i] & black;
} while (++i != w);
memcpy(dst + 640, dst, w * 2);
dst += 640 * 2;
src += 320;
} while (--h);
#else
do {
i = 0;
do {
dst[i * 2] = dst[i * 2 + 1] = src[i];
} while (++i != w);
memcpy(dst + 640, dst, w * 2);
dst += 640 * 2;
src += 320;
} while (--h);
#endif
} else {
dst = (byte *)screen->pixels + y * 320 + x;
addDirtyRect(x, y, w, h);
do {
memcpy(dst, src, w);
dst += 320;
src += 320;
} while (--h);
}
SDL_UnlockSurface(screen);
}
void Draw2xSaI(SDL_Rect * r, int vidmode)
{
if (SDL_BlitSurface(screen, r, sdl_tmpscreen, r) != 0)
error("SDL_BlitSurface failed");
SDL_LockSurface(sdl_tmpscreen);
SDL_LockSurface(sdl_hwscreen);
switch (vidmode) {
case VIDEO_2XSAI:
_2xSaI((byte *)sdl_tmpscreen->pixels + r->x * 2 + r->y * 640, 640, NULL,
(byte *)sdl_hwscreen->pixels + r->x * 4 + r->y * 640 * 4, 640 * 2,
r->w, r->h);
break;
case VIDEO_SUPERSAI:
Super2xSaI((byte *)sdl_tmpscreen->pixels + r->x * 2 + r->y * 640, 640,
NULL, (byte *)sdl_hwscreen->pixels + r->x * 4 + r->y * 640 * 4,
640 * 2, r->w, r->h);
break;
case VIDEO_SUPEREAGLE:
SuperEagle((byte *)sdl_tmpscreen->pixels + r->x * 2 + r->y * 640, 640,
NULL, (byte *)sdl_hwscreen->pixels + r->x * 4 + r->y * 640 * 4,
640 * 2, r->w, r->h);
break;
default:
error("Unknown graphics mode %d", vidmode);
break;
}
/* scale the rect to fit in SDL_UpdateRects */
r->x <<= 1;
r->y <<= 1;
r->w <<= 1;
r->h <<= 1;
SDL_UnlockSurface(sdl_tmpscreen);
SDL_UnlockSurface(sdl_hwscreen);
SDL_UpdateRect(sdl_hwscreen, r->x, r->y, r->w, r->h);
}
void updateScreen2xSaI(Scumm *s)
{
SDL_Rect r;
if (s->_fastMode & 2)
return;
if (hide_mouse) {
hide_mouse = false;
s->drawMouse();
}
if (s->_palDirtyMax != -1)
updatePalette(s);
if (fullRedraw) {
r.x = 0;
r.y = 0;
r.w = 320;
r.h = 200;
Draw2xSaI(&r, s->_videoMode);
fullRedraw = false;
return;
} else if (numDirtyRects) {
SDL_Rect *dr;
int i;
for (i = 0; i < numDirtyRects; i++) {
dr = &dirtyRects[i];
Draw2xSaI(dr, s->_videoMode);
}
}
numDirtyRects = 0;
}
void updateScreenScale(Scumm *s)
{
if (fullRedraw) {
SDL_UpdateRect(screen, 0, 0, 0, 0);
fullRedraw = false;
} else if (numDirtyRects) {
SDL_UpdateRects(screen, numDirtyRects, dirtyRects);
}
numDirtyRects = 0;
}
void updateScreen(Scumm *s)
{
if (s->_fastMode & 2)
return;
if (hide_mouse) {
hide_mouse = false;
s->drawMouse();
}
if (s->_palDirtyMax != -1) {
updatePalette(s);
}
if (s->_videoMode == VIDEO_SCALE)
updateScreenScale(s);
else
updateScreen2xSaI(s);
}
void drawMouse(Scumm *s, int xdraw, int ydraw, int w, int h, byte *buf,
bool visible)
{
int x, y;
byte *dst, *bak;
byte color;
if (hide_mouse)
visible = false;
assert(w <= BAK_WIDTH && h <= BAK_HEIGHT);
if (SDL_LockSurface(screen) == -1)
error("SDL_LockSurface failed: %s.\n", SDL_GetError());
if (scale == 3) {
if (has_mouse) {
dst = (byte *)screen->pixels + old_mouse_y * 960 * 3 + old_mouse_x * 3;
bak = old_backup;
for (y = 0; y < old_mouse_h; y++, bak += BAK_WIDTH * 3, dst += 960 * 3) {
if ((uint) (old_mouse_y + y) < 200) {
for (x = 0; x < old_mouse_w; x++) {
if ((uint) (old_mouse_x + x) < 320) {
dst[x * 3 + 960] = dst[x * 3 + 960 + 960] = dst[x * 3] =
bak[x * 3];
dst[x * 3 + 960 + 1] = dst[x * 3 + 960 + 960 + 1] =
dst[x * 3 + 1] = bak[x * 3 + 1];
dst[x * 3 + 960 + 2] = dst[x * 3 + 960 + 960 + 2] =
dst[x * 3 + 2] = bak[x * 3 + 2];
}
}
}
}
}
if (visible) {
ydraw += current_shake_pos;
dst = (byte *)screen->pixels + ydraw * 960 * 3 + xdraw * 3;
bak = old_backup;
for (y = 0; y < h; y++, dst += 960 * 3, bak += BAK_WIDTH * 3, buf += w) {
if ((uint) (ydraw + y) < 200) {
for (x = 0; x < w; x++) {
if ((uint) (xdraw + x) < 320) {
bak[x * 3] = dst[x * 3];
bak[x * 3 + 1] = dst[x * 3 + 1];
bak[x * 3 + 2] = dst[x * 3 + 2];
if ((color = buf[x]) != 0xFF) {
dst[x * 3] = color;
dst[x * 3 + 1] = color;
dst[x * 3 + 2] = color;
dst[x * 3 + 960] = color;
dst[x * 3 + 1 + 960] = color;
dst[x * 3 + 2 + 960] = color;
dst[x * 3 + 960 + 960] = color;
dst[x * 3 + 1 + 960 + 960] = color;
dst[x * 3 + 2 + 960 + 960] = color;
}
}
}
}
}
}
} else if (scale == 2) {
if (has_mouse) {
dst = (byte *)screen->pixels + old_mouse_y * 640 * 2 + old_mouse_x * 2;
bak = old_backup;
for (y = 0; y < old_mouse_h; y++, bak += BAK_WIDTH * 2, dst += 640 * 2) {
if ((uint) (old_mouse_y + y) < 200) {
for (x = 0; x < old_mouse_w; x++) {
if ((uint) (old_mouse_x + x) < 320) {
dst[x * 2 + 640] = dst[x * 2] = bak[x * 2];
dst[x * 2 + 640 + 1] = dst[x * 2 + 1] = bak[x * 2 + 1];
}
}
}
}
}
if (visible) {
ydraw += current_shake_pos;
dst = (byte *)screen->pixels + ydraw * 640 * 2 + xdraw * 2;
bak = old_backup;
for (y = 0; y < h; y++, dst += 640 * 2, bak += BAK_WIDTH * 2, buf += w) {
if ((uint) (ydraw + y) < 200) {
for (x = 0; x < w; x++) {
if ((uint) (xdraw + x) < 320) {
bak[x * 2] = dst[x * 2];
bak[x * 2 + 1] = dst[x * 2 + 1];
if ((color = buf[x]) != 0xFF) {
dst[x * 2] = color;
dst[x * 2 + 1] = color;
dst[x * 2 + 640] = color;
dst[x * 2 + 1 + 640] = color;
}
}
}
}
}
}
} else {
if (has_mouse) {
dst = (byte *)screen->pixels + old_mouse_y * 320 + old_mouse_x;
bak = old_backup;
for (y = 0; y < old_mouse_h; y++, bak += BAK_WIDTH, dst += 320) {
if ((uint) (old_mouse_y + y) < 200) {
for (x = 0; x < old_mouse_w; x++) {
if ((uint) (old_mouse_x + x) < 320) {
dst[x] = bak[x];
}
}
}
}
}
if (visible) {
ydraw += current_shake_pos;
dst = (byte *)screen->pixels + ydraw * 320 + xdraw;
bak = old_backup;
for (y = 0; y < h; y++, dst += 320, bak += BAK_WIDTH, buf += w) {
if ((uint) (ydraw + y) < 200) {
for (x = 0; x < w; x++) {
if ((uint) (xdraw + x) < 320) {
bak[x] = dst[x];
if ((color = buf[x]) != 0xFF) {
dst[x] = color;
}
}
}
}
}
}
}
SDL_UnlockSurface(screen);
if (has_mouse) {
has_mouse = false;
addDirtyRectClipped(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
}
if (visible) {
has_mouse = true;
addDirtyRectClipped(xdraw, ydraw, w, h);
old_mouse_x = xdraw;
old_mouse_y = ydraw;
old_mouse_w = w;
old_mouse_h = h;
}
}
void fill_sound(void *userdata, Uint8 * stream, int len)
{
g_scumm->mixWaves((int16 *) stream, len >> 1);
}
static int cd_track, cd_num_loops = 0, cd_start_frame, cd_end_frame;
// On my system, calling SDL_CDStatus all the time slows things down a
// lot and prevents music from playing at all :( So this saves the
// time the track is expected to be finished.
static Uint32 cd_end_time, cd_stop_time, cd_next_second;
void cd_play(Scumm *s, int track, int num_loops, int start_frame,
int end_frame)
{
/* FIXME: what does this code do? */
g_scumm->_vars[14] = 0;
if (!num_loops && !start_frame)
return;
#ifdef COMPRESSED_SOUND_FILE
if (mp3_cd_play(s, track, num_loops, start_frame, end_frame))
return;
#endif
// warning("cd_play(%d,%d,%d,%d)", track, num_loops, start_frame, end_frame);
if (!cdrom)
return;
cd_track = track;
cd_num_loops = num_loops;
cd_start_frame = start_frame;
SDL_CDStatus(cdrom);
SDL_CDPlayTracks(cdrom, track, start_frame, 0, end_frame);
cd_end_frame = end_frame;
cd_stop_time = 0;
cd_end_time = SDL_GetTicks() + cdrom->track[track].length * 1000 / CD_FPS;
}
// Schedule the music to be stopped after 1/10 sec, unless another
// track is started in the meantime. (On my machine, stopping and
// then restarting the CD takes a few seconds.)
void cd_stop()
{
cd_stop_time = SDL_GetTicks() + 100;
cd_num_loops = 0;
}
int cd_is_running()
{
if (!cdrom)
return 0;
return (cd_num_loops != 0 && (SDL_GetTicks() < cd_end_time ||
SDL_CDStatus(cdrom) != CD_STOPPED));
}
static void cd_shutdown()
{
if (!cdrom)
return;
if (cd_num_loops != 0)
SDL_CDStop(cdrom);
}
void cd_music_loop()
{
if (!cdrom)
return;
/* if (SDL_GetTicks() >= cd_next_second) {
/ printf("%d started at %d, fps\n", scumm._vars[14], cd_start_frame, CD_FPS);
//scumm._vars[14]++; //varmusicflag
cd_next_second = SDL_GetTicks() + 1;
} */
if (cd_stop_time != 0 && SDL_GetTicks() >= cd_stop_time) {
SDL_CDStop(cdrom);
cd_num_loops = 0;
cd_stop_time = 0;
return;
}
if (cd_num_loops == 0 || SDL_GetTicks() < cd_end_time)
return;
if (cd_num_loops != 1 && SDL_CDStatus(cdrom) != CD_STOPPED) {
// Wait another second for it to be done
cd_end_time += 1000;
return;
}
if (cd_num_loops > 0)
cd_num_loops--;
if (cd_num_loops != 0) {
SDL_CDPlayTracks(cdrom, cd_track, cd_start_frame, 0, cd_end_frame);
cd_end_time =
SDL_GetTicks() + cdrom->track[cd_track].length * 1000 / CD_FPS;
}
}
int music_thread(Scumm *s)
{
int old_time, cur_time;
old_time = SDL_GetTicks();
do {
SDL_Delay(10);
cur_time = SDL_GetTicks();
while (old_time < cur_time) {
old_time += 10;
sound.on_timer();
}
} while (1);
return 0;
}
void initGraphics(Scumm *s, bool fullScreen, unsigned int scaleFactor)
{
SDL_AudioSpec desired;
scale = scaleFactor;
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) == -1) {
error("Could not initialize SDL: %s.\n", SDL_GetError());
exit(1);
}
if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1)
cdrom = NULL;
else {
cdrom = SDL_CDOpen(s->_cdrom);
/* Did if open? Check if cdrom is NULL */
if (!cdrom) {
warning("Couldn't open drive: %s\n", SDL_GetError());
}
}
/* Clean up on exit */
atexit(SDL_Quit);
atexit(cd_shutdown);
atexit(resetCursor);
char buf[512], *gameName;
sprintf(buf, "ScummVM - %s", gameName = detector.getGameName());
free(gameName);
desired.freq = SAMPLES_PER_SEC;
desired.format = AUDIO_S16SYS;
desired.channels = 1;
desired.samples = 2048;
desired.callback = fill_sound;
SDL_OpenAudio(&desired, NULL);
SDL_PauseAudio(0);
SDL_WM_SetCaption(buf, buf);
SDL_ShowCursor(SDL_DISABLE);
if (!snd_driv.wave_based()) {
/* Create Music Thread */
SDL_CreateThread((int (*)(void *))&music_thread, s);
}
if (s->_videoMode == VIDEO_SCALE) {
screen =
SDL_SetVideoMode(320 * scale, 200 * scale, 8,
fullScreen ? (SDL_SWSURFACE | SDL_FULLSCREEN)
: (SDL_SWSURFACE | SDL_DOUBLEBUF));
} else {
uint16 *tmp_screen = (uint16 *)calloc(320 * 202 + 8, sizeof(uint16));
Init_2xSaI(565);
screen = SDL_CreateRGBSurface(SDL_SWSURFACE, 320, 200, 8, 0, 0, 0, 0);
sdl_hwscreen =
SDL_SetVideoMode(640, 400, 16,
fullScreen ? (SDL_SWSURFACE | SDL_FULLSCREEN)
: (SDL_SWSURFACE | SDL_DOUBLEBUF));
sdl_tmpscreen =
SDL_CreateRGBSurfaceFrom(tmp_screen + 320 + 4, 320, 200, 16, 320 * 2, 0,
0, 0, 0);
if (sdl_tmpscreen == NULL)
error("sdl_tmpscreen failed");
scale = 1;
}
// SDL_SWSURFACE 0x00000000 /* Surface is in system memory */
// SDL_HWSURFACE 0x00000001 /* Surface is in video memory */
// SDL_ASYNCBLIT 0x00000004 /* Use asynchronous blits if possible */
// SDL_ANYFORMAT 0x10000000 /* Allow any video depth/pixel-format */
// SDL_HWPALETTE 0x20000000 /* Surface has exclusive palette */
// SDL_DOUBLEBUF 0x40000000 /* Set up double-buffered video mode */
// SDL_FULLSCREEN 0x80000000 /* Surface is a full screen display */
// SDL_OPENGL 0x00000002 /* Create an OpenGL rendering context */
// SDL_OPENGLBLIT 0x0000000A /* Create an OpenGL rendering context and use it for blitting */
// SDL_RESIZABLE 0x00000010 /* This video mode may be resized */
// SDL_NOFRAME 0x00000020 /* No window caption or edge frame */
printf("%d %d, %d %d, %d %d %d, %d %d %d %d %d\n",
sizeof(int8), sizeof(uint8),
sizeof(int16), sizeof(uint16),
sizeof(int32), sizeof(uint32),
sizeof(void *),
sizeof(Box), sizeof(MouseCursor), sizeof(CodeHeader),
sizeof(ImageHeader), sizeof(Scumm)
);
}
void setWindowName(Scumm *s)
{
char buf[512], *gameName;
sprintf(buf, "ScummVM - %s", gameName = detector.getGameName());
free(gameName);
SDL_WM_SetCaption(buf, buf);
}
#if !defined(__APPLE__)
#undef main
#endif
void launcherLoop()
{
int last_time, new_time;
int delta = 0;
last_time = SDL_GetTicks();
gui.launcher(g_scumm);
do {
updateScreen(g_scumm);
new_time = SDL_GetTicks();
waitForTimer(g_scumm, delta * 15 + last_time - new_time);
last_time = SDL_GetTicks();
if (gui._active) {
gui.loop(g_scumm);
delta = 5;
} else
error("gui closed!");
} while (1);
};
int main(int argc, char *argv[])
{
#if defined(MACOS)
/* support for config file on macos */
char *argitem;
char *argstr;
FILE *argf;
if ((argf = fopen("configuration.macos", "r")) == NULL) {
error("Can't open configuration file.\n");
exit(1);
}
argc = 0;
argstr = (char *)malloc(64);
argstr = fgets(argstr, 64, argf);
if ((argitem = strchr(argstr, '\n')) != NULL)
*argitem = '\0';
argitem = strtok(argstr, " ");
while (argitem != NULL) {
argv = (char **)realloc(argv, (argc + 1) * 8);
argv[argc] = (char *)malloc(64);
strcpy(argv[argc], argitem);
argc++;
argitem = strtok(NULL, " ");
}
free(argstr);
fclose(argf);
#endif
if (detector.detectMain(argc, argv))
return (-1);
/* Simon the Sorcerer? */
if (detector._gameId >= GID_SIMON_FIRST && detector._gameId <= GID_SIMON_LAST) {
/* Simon the Sorcerer. Completely different initialization */
} else {
Scumm *scumm = Scumm::createFromDetector(&detector);
g_scumm = scumm;
sound.initialize(scumm, &snd_driv);
/* bind to Gui */
scumm->_gui = &gui;
gui.init(scumm); /* Reinit GUI after loading a game */
/* Bind to OSystem */
scumm->_system = &_system;
_system.last_time = 0;
scumm->go();
}
return 0;
}
/************ ENDER: Temporary debug code for boxen **************/
int hlineColor(SDL_Surface * dst, Sint16 x1, Sint16 x2, Sint16 y,
Uint32 color)
{
Sint16 left, right, top, bottom;
Uint8 *pixel, *pixellast;
int dx;
int pixx, pixy;
Sint16 w;
Sint16 xtmp;
int result = -1;
Uint8 *colorptr;
/* Get clipping boundary */
left = dst->clip_rect.x;
right = dst->clip_rect.x + dst->clip_rect.w - 1;
top = dst->clip_rect.y;
bottom = dst->clip_rect.y + dst->clip_rect.h - 1;
/* Swap x1, x2 if required */
if (x1 > x2) {
xtmp = x1;
x1 = x2;
x2 = xtmp;
}
/* Visible */
if ((x1 > right) || (x2 < left) || (y < top) || (y > bottom)) {
return (0);
}
/* Clip x */
if (x1 < left) {
x1 = left;
}
if (x2 > right) {
x2 = right;
}
/* Calculate width */
w = x2 - x1;
/* Sanity check on width */
if (w < 0) {
return (0);
}
/* Setup color */
colorptr = (Uint8 *) & color;
if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
color =
SDL_MapRGBA(dst->format, colorptr[0], colorptr[1], colorptr[2],
colorptr[3]);
} else {
color =
SDL_MapRGBA(dst->format, colorptr[3], colorptr[2], colorptr[1],
colorptr[0]);
}
/* Lock surface */
SDL_LockSurface(dst);
/* More variable setup */
dx = w;
pixx = dst->format->BytesPerPixel;
pixy = dst->pitch;
pixel = ((Uint8 *) dst->pixels) + pixx * (int)x1 + pixy * (int)y;
/* Draw */
switch (dst->format->BytesPerPixel) {
case 1:
memset(pixel, color, dx);
break;
case 2:
pixellast = pixel + dx + dx;
for (; pixel <= pixellast; pixel += pixx) {
*(Uint16 *) pixel = color;
}
break;
case 3:
pixellast = pixel + dx + dx + dx;
for (; pixel <= pixellast; pixel += pixx) {
if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
pixel[0] = (color >> 16) & 0xff;
pixel[1] = (color >> 8) & 0xff;
pixel[2] = color & 0xff;
} else {
pixel[0] = color & 0xff;
pixel[1] = (color >> 8) & 0xff;
pixel[2] = (color >> 16) & 0xff;
}
}
break;
default: /* case 4 */
dx = dx + dx;
pixellast = pixel + dx + dx;
for (; pixel <= pixellast; pixel += pixx) {
*(Uint32 *) pixel = color;
}
break;
}
/* Unlock surface */
SDL_UnlockSurface(dst);
/* Set result code */
result = 0;
return (result);
}
int gfxPrimitivesCompareInt(const void *a, const void *b);
static int *gfxPrimitivesPolyInts = NULL;
static int gfxPrimitivesPolyAllocated = 0;
int filledPolygonColor(SDL_Surface * dst, Sint16 * vx, Sint16 * vy, int n,
int color)
{
int result;
int i;
int y;
int miny, maxy;
int x1, y1;
int x2, y2;
int ind1, ind2;
int ints;
/* Sanity check */
if (n < 3) {
return -1;
}
/* Allocate temp array, only grow array */
if (!gfxPrimitivesPolyAllocated) {
gfxPrimitivesPolyInts = (int *)malloc(sizeof(int) * n);
gfxPrimitivesPolyAllocated = n;
} else {
if (gfxPrimitivesPolyAllocated < n) {
gfxPrimitivesPolyInts =
(int *)realloc(gfxPrimitivesPolyInts, sizeof(int) * n);
gfxPrimitivesPolyAllocated = n;
}
}
/* Determine Y maxima */
miny = vy[0];
maxy = vy[0];
for (i = 1; (i < n); i++) {
if (vy[i] < miny) {
miny = vy[i];
} else if (vy[i] > maxy) {
maxy = vy[i];
}
}
/* Draw, scanning y */
result = 0;
for (y = miny; (y <= maxy); y++) {
ints = 0;
for (i = 0; (i < n); i++) {
if (!i) {
ind1 = n - 1;
ind2 = 0;
} else {
ind1 = i - 1;
ind2 = i;
}
y1 = vy[ind1];
y2 = vy[ind2];
if (y1 < y2) {
x1 = vx[ind1];
x2 = vx[ind2];
} else if (y1 > y2) {
y2 = vy[ind1];
y1 = vy[ind2];
x2 = vx[ind1];
x1 = vx[ind2];
} else {
continue;
}
if ((y >= y1) && (y < y2)) {
gfxPrimitivesPolyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1;
} else if ((y == maxy) && (y > y1) && (y <= y2)) {
gfxPrimitivesPolyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1;
}
}
qsort(gfxPrimitivesPolyInts, ints, sizeof(int), gfxPrimitivesCompareInt);
for (i = 0; (i < ints); i += 2) {
result |=
hlineColor(dst, gfxPrimitivesPolyInts[i],
gfxPrimitivesPolyInts[i + 1], y, color);
}
}
return (result);
}
int gfxPrimitivesCompareInt(const void *a, const void *b)
{
return (*(const int *)a) - (*(const int *)b);
}
/* FIXME: What's the purpose of this function?
* Functions should start with a small letter.
*/
void BoxTest(int num)
{
BoxCoords box;
Sint16 rx1[4], ry1[4];
g_scumm->getBoxCoordinates(num, &box);
rx1[0] = box.ul.x * 2;
ry1[0] = box.ul.y * 2 + 32;
rx1[1] = box.ur.x * 2;
ry1[1] = box.ur.y * 2 + 32;
rx1[2] = box.ll.x * 2;
ry1[2] = box.ll.y * 2 + 32;
rx1[3] = box.lr.x * 2;
ry1[3] = box.lr.y * 2 + 32;
filledPolygonColor(screen, &rx1[0], &ry1[0], 4, 255);
SDL_UpdateRect(screen, 0, 0, 0, 0);
}
/* FIXME: 2xSAI Functions should be moved to a separate
* source file
*/
/********* ScummVM call back functions **********/
int OSystem::waitTick(int delta)
{
do {
updateScreen(g_scumm);
new_time = SDL_GetTicks();
waitForTimer(g_scumm, delta * 15 + last_time - new_time);
last_time = SDL_GetTicks();
if (gui._active) {
gui.loop(g_scumm);
delta = 5;
}
} while (gui._active);
return (delta);
}
OSystem::OSystem()
{
last_time = SDL_GetTicks();
}
Reference in a new issue View git blame Copy permalink