/* 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(); }