mirror of
https://github.com/libretro/scummvm.git
synced 2025-02-05 18:41:12 +00:00
renamed a few things to match our coding guidelines
simplified OSystem_SDL destructor and move all the SDL uninitialization stuff to the quit() method made saveScreenshot() returning false on fail svn-id: r15967
This commit is contained in:
Gregory Montoir
parent
8bbbbc71fb
commit
cdec823d98
@ -64,8 +64,8 @@ void OSystem_SDL::fillMouseEvent(Event &event, int x, int y) {
|
||||
event.mouse.y = y;
|
||||
|
||||
// Update the "keyboard mouse" coords
|
||||
km.x = x;
|
||||
km.y = y;
|
||||
_km.x = x;
|
||||
_km.y = y;
|
||||
|
||||
// Adjust for the screen scaling
|
||||
event.mouse.x /= _scaleFactor;
|
||||
@ -76,71 +76,71 @@ void OSystem_SDL::fillMouseEvent(Event &event, int x, int y) {
|
||||
event.mouse.y = aspect2Real(event.mouse.y);
|
||||
}
|
||||
|
||||
void OSystem_SDL::kbd_mouse() {
|
||||
void OSystem_SDL::handleKbdMouse() {
|
||||
uint32 curTime = getMillis();
|
||||
if (curTime >= km.last_time + km.delay_time) {
|
||||
km.last_time = curTime;
|
||||
if (km.x_down_count == 1) {
|
||||
km.x_down_time = curTime;
|
||||
km.x_down_count = 2;
|
||||
if (curTime >= _km.last_time + _km.delay_time) {
|
||||
_km.last_time = curTime;
|
||||
if (_km.x_down_count == 1) {
|
||||
_km.x_down_time = curTime;
|
||||
_km.x_down_count = 2;
|
||||
}
|
||||
if (km.y_down_count == 1) {
|
||||
km.y_down_time = curTime;
|
||||
km.y_down_count = 2;
|
||||
if (_km.y_down_count == 1) {
|
||||
_km.y_down_time = curTime;
|
||||
_km.y_down_count = 2;
|
||||
}
|
||||
|
||||
if (km.x_vel || km.y_vel) {
|
||||
if (km.x_down_count) {
|
||||
if (curTime > km.x_down_time + km.delay_time * 12) {
|
||||
if (km.x_vel > 0)
|
||||
km.x_vel++;
|
||||
if (_km.x_vel || _km.y_vel) {
|
||||
if (_km.x_down_count) {
|
||||
if (curTime > _km.x_down_time + _km.delay_time * 12) {
|
||||
if (_km.x_vel > 0)
|
||||
_km.x_vel++;
|
||||
else
|
||||
km.x_vel--;
|
||||
} else if (curTime > km.x_down_time + km.delay_time * 8) {
|
||||
if (km.x_vel > 0)
|
||||
km.x_vel = 5;
|
||||
_km.x_vel--;
|
||||
} else if (curTime > _km.x_down_time + _km.delay_time * 8) {
|
||||
if (_km.x_vel > 0)
|
||||
_km.x_vel = 5;
|
||||
else
|
||||
km.x_vel = -5;
|
||||
_km.x_vel = -5;
|
||||
}
|
||||
}
|
||||
if (km.y_down_count) {
|
||||
if (curTime > km.y_down_time + km.delay_time * 12) {
|
||||
if (km.y_vel > 0)
|
||||
km.y_vel++;
|
||||
if (_km.y_down_count) {
|
||||
if (curTime > _km.y_down_time + _km.delay_time * 12) {
|
||||
if (_km.y_vel > 0)
|
||||
_km.y_vel++;
|
||||
else
|
||||
km.y_vel--;
|
||||
} else if (curTime > km.y_down_time + km.delay_time * 8) {
|
||||
if (km.y_vel > 0)
|
||||
km.y_vel = 5;
|
||||
_km.y_vel--;
|
||||
} else if (curTime > _km.y_down_time + _km.delay_time * 8) {
|
||||
if (_km.y_vel > 0)
|
||||
_km.y_vel = 5;
|
||||
else
|
||||
km.y_vel = -5;
|
||||
_km.y_vel = -5;
|
||||
}
|
||||
}
|
||||
|
||||
km.x += km.x_vel;
|
||||
km.y += km.y_vel;
|
||||
_km.x += _km.x_vel;
|
||||
_km.y += _km.y_vel;
|
||||
|
||||
if (km.x < 0) {
|
||||
km.x = 0;
|
||||
km.x_vel = -1;
|
||||
km.x_down_count = 1;
|
||||
} else if (km.x > km.x_max) {
|
||||
km.x = km.x_max;
|
||||
km.x_vel = 1;
|
||||
km.x_down_count = 1;
|
||||
if (_km.x < 0) {
|
||||
_km.x = 0;
|
||||
_km.x_vel = -1;
|
||||
_km.x_down_count = 1;
|
||||
} else if (_km.x > _km.x_max) {
|
||||
_km.x = _km.x_max;
|
||||
_km.x_vel = 1;
|
||||
_km.x_down_count = 1;
|
||||
}
|
||||
|
||||
if (km.y < 0) {
|
||||
km.y = 0;
|
||||
km.y_vel = -1;
|
||||
km.y_down_count = 1;
|
||||
} else if (km.y > km.y_max) {
|
||||
km.y = km.y_max;
|
||||
km.y_vel = 1;
|
||||
km.y_down_count = 1;
|
||||
if (_km.y < 0) {
|
||||
_km.y = 0;
|
||||
_km.y_vel = -1;
|
||||
_km.y_down_count = 1;
|
||||
} else if (_km.y > _km.y_max) {
|
||||
_km.y = _km.y_max;
|
||||
_km.y_vel = 1;
|
||||
_km.y_down_count = 1;
|
||||
}
|
||||
|
||||
SDL_WarpMouse(km.x, km.y);
|
||||
SDL_WarpMouse(_km.x, _km.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -150,7 +150,7 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
int axis;
|
||||
byte b = 0;
|
||||
|
||||
kbd_mouse();
|
||||
handleKbdMouse();
|
||||
|
||||
// If the screen mode changed, send an EVENT_SCREEN_CHANGED
|
||||
if (_modeChanged) {
|
||||
@ -182,9 +182,9 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
// Alt-Return and Alt-Enter toggle full screen mode
|
||||
if (b == KBD_ALT && (ev.key.keysym.sym == SDLK_RETURN
|
||||
|| ev.key.keysym.sym == SDLK_KP_ENTER)) {
|
||||
setFullscreenMode(!_full_screen);
|
||||
setFullscreenMode(!_fullscreen);
|
||||
#ifdef USE_OSD
|
||||
if (_full_screen)
|
||||
if (_fullscreen)
|
||||
displayMessageOnOSD("Fullscreen mode");
|
||||
else
|
||||
displayMessageOnOSD("Windowed mode");
|
||||
@ -206,7 +206,7 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
break;
|
||||
SDL_RWclose(file);
|
||||
}
|
||||
if (save_screenshot(filename))
|
||||
if (saveScreenshot(filename))
|
||||
printf("Saved '%s'\n", filename);
|
||||
else
|
||||
printf("Could not save screenshot!\n");
|
||||
@ -321,26 +321,26 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
|
||||
#ifdef LINUPY
|
||||
// On Yopy map the End button to quit
|
||||
if ((ev.key.keysym.sym==293)) {
|
||||
if ((ev.key.keysym.sym == 293)) {
|
||||
event.event_code = EVENT_QUIT;
|
||||
return true;
|
||||
}
|
||||
// Map menu key to f5 (scumm menu)
|
||||
if (ev.key.keysym.sym==306) {
|
||||
if (ev.key.keysym.sym == 306) {
|
||||
event.event_code = EVENT_KEYDOWN;
|
||||
event.kbd.keycode = SDLK_F5;
|
||||
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
|
||||
return true;
|
||||
}
|
||||
// Map action key to action
|
||||
if (ev.key.keysym.sym==291) {
|
||||
if (ev.key.keysym.sym == 291) {
|
||||
event.event_code = EVENT_KEYDOWN;
|
||||
event.kbd.keycode = SDLK_TAB;
|
||||
event.kbd.ascii = mapKey(SDLK_TAB, ev.key.keysym.mod, 0);
|
||||
return true;
|
||||
}
|
||||
// Map OK key to skip cinematic
|
||||
if (ev.key.keysym.sym==292) {
|
||||
if (ev.key.keysym.sym == 292) {
|
||||
event.event_code = EVENT_KEYDOWN;
|
||||
event.kbd.keycode = SDLK_ESCAPE;
|
||||
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
|
||||
@ -390,20 +390,20 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
|
||||
switch(ev.key.keysym.sym) {
|
||||
case SDLK_LEFT:
|
||||
km.x_vel = -1;
|
||||
km.x_down_count = 1;
|
||||
_km.x_vel = -1;
|
||||
_km.x_down_count = 1;
|
||||
break;
|
||||
case SDLK_RIGHT:
|
||||
km.x_vel = 1;
|
||||
km.x_down_count = 1;
|
||||
_km.x_vel = 1;
|
||||
_km.x_down_count = 1;
|
||||
break;
|
||||
case SDLK_UP:
|
||||
km.y_vel = -1;
|
||||
km.y_down_count = 1;
|
||||
_km.y_vel = -1;
|
||||
_km.y_down_count = 1;
|
||||
break;
|
||||
case SDLK_DOWN:
|
||||
km.y_vel = 1;
|
||||
km.y_down_count = 1;
|
||||
_km.y_vel = 1;
|
||||
_km.y_down_count = 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
@ -418,27 +418,27 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
|
||||
switch(ev.key.keysym.sym) {
|
||||
case SDLK_LEFT:
|
||||
if (km.x_vel < 0) {
|
||||
km.x_vel = 0;
|
||||
km.x_down_count = 0;
|
||||
if (_km.x_vel < 0) {
|
||||
_km.x_vel = 0;
|
||||
_km.x_down_count = 0;
|
||||
}
|
||||
break;
|
||||
case SDLK_RIGHT:
|
||||
if (km.x_vel > 0) {
|
||||
km.x_vel = 0;
|
||||
km.x_down_count = 0;
|
||||
if (_km.x_vel > 0) {
|
||||
_km.x_vel = 0;
|
||||
_km.x_down_count = 0;
|
||||
}
|
||||
break;
|
||||
case SDLK_UP:
|
||||
if (km.y_vel < 0) {
|
||||
km.y_vel = 0;
|
||||
km.y_down_count = 0;
|
||||
if (_km.y_vel < 0) {
|
||||
_km.y_vel = 0;
|
||||
_km.y_down_count = 0;
|
||||
}
|
||||
break;
|
||||
case SDLK_DOWN:
|
||||
if (km.y_vel > 0) {
|
||||
km.y_vel = 0;
|
||||
km.y_down_count = 0;
|
||||
if (_km.y_vel > 0) {
|
||||
_km.y_vel = 0;
|
||||
_km.y_down_count = 0;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
@ -450,7 +450,7 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
event.event_code = EVENT_MOUSEMOVE;
|
||||
fillMouseEvent(event, ev.motion.x, ev.motion.y);
|
||||
|
||||
set_mouse_pos(event.mouse.x, event.mouse.y);
|
||||
setMousePos(event.mouse.x, event.mouse.y);
|
||||
return true;
|
||||
|
||||
case SDL_MOUSEBUTTONDOWN:
|
||||
@ -551,15 +551,15 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
|
||||
if ( ev.jaxis.axis == JOY_XAXIS) {
|
||||
#ifdef JOY_ANALOG
|
||||
km.x_vel = axis/2000;
|
||||
km.x_down_count = 0;
|
||||
_km.x_vel = axis/2000;
|
||||
_km.x_down_count = 0;
|
||||
#else
|
||||
if (axis != 0) {
|
||||
km.x_vel = (axis > 0) ? 1:-1;
|
||||
km.x_down_count = 1;
|
||||
_km.x_vel = (axis > 0) ? 1:-1;
|
||||
_km.x_down_count = 1;
|
||||
} else {
|
||||
km.x_vel = 0;
|
||||
km.x_down_count = 0;
|
||||
_km.x_vel = 0;
|
||||
_km.x_down_count = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -568,20 +568,20 @@ bool OSystem_SDL::pollEvent(Event &event) {
|
||||
axis = -axis;
|
||||
#endif
|
||||
#ifdef JOY_ANALOG
|
||||
km.y_vel = -axis / 2000;
|
||||
km.y_down_count = 0;
|
||||
_km.y_vel = -axis / 2000;
|
||||
_km.y_down_count = 0;
|
||||
#else
|
||||
if (axis != 0) {
|
||||
km.y_vel = (-axis > 0) ? 1: -1;
|
||||
km.y_down_count = 1;
|
||||
_km.y_vel = (-axis > 0) ? 1: -1;
|
||||
_km.y_down_count = 1;
|
||||
} else {
|
||||
km.y_vel = 0;
|
||||
km.y_down_count = 0;
|
||||
_km.y_vel = 0;
|
||||
_km.y_down_count = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
fillMouseEvent(event, km.x, km.y);
|
||||
fillMouseEvent(event, _km.x, _km.y);
|
||||
|
||||
return true;
|
||||
|
||||
|
||||
@ -158,7 +158,7 @@ bool OSystem_SDL::setGraphicsMode(int mode) {
|
||||
_scalerProc = newScalerProc;
|
||||
if (newScaleFactor != _scaleFactor) {
|
||||
_scaleFactor = newScaleFactor;
|
||||
hotswap_gfx_mode();
|
||||
hotswapGFXMode();
|
||||
}
|
||||
|
||||
// Determine the "scaler type", i.e. essentially an index into the
|
||||
@ -215,20 +215,20 @@ void OSystem_SDL::initSize(uint w, uint h) {
|
||||
if (h != 200)
|
||||
_adjustAspectRatio = false;
|
||||
|
||||
CKSUM_NUM = (_screenWidth * _screenHeight / (8 * 8));
|
||||
_cksumNum = (_screenWidth * _screenHeight / (8 * 8));
|
||||
|
||||
free(_dirty_checksums);
|
||||
_dirty_checksums = (uint32 *)calloc(CKSUM_NUM * 2, sizeof(uint32));
|
||||
free(_dirtyChecksums);
|
||||
_dirtyChecksums = (uint32 *)calloc(_cksumNum * 2, sizeof(uint32));
|
||||
|
||||
_mouseData = NULL;
|
||||
|
||||
unload_gfx_mode();
|
||||
load_gfx_mode();
|
||||
unloadGFXMode();
|
||||
loadGFXMode();
|
||||
}
|
||||
|
||||
void OSystem_SDL::load_gfx_mode() {
|
||||
void OSystem_SDL::loadGFXMode() {
|
||||
_forceFull = true;
|
||||
_mode_flags |= DF_UPDATE_EXPAND_1_PIXEL;
|
||||
_modeFlags |= DF_UPDATE_EXPAND_1_PIXEL;
|
||||
|
||||
_tmpscreen = NULL;
|
||||
|
||||
@ -244,7 +244,7 @@ void OSystem_SDL::load_gfx_mode() {
|
||||
//
|
||||
|
||||
_hwscreen = SDL_SetVideoMode(_screenWidth * _scaleFactor, effectiveScreenHeight(), 16,
|
||||
_full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
|
||||
_fullscreen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
|
||||
);
|
||||
if (_hwscreen == NULL) {
|
||||
// DON'T use error(), as this tries to bring up the debug
|
||||
@ -305,13 +305,13 @@ void OSystem_SDL::load_gfx_mode() {
|
||||
#endif
|
||||
|
||||
// keyboard cursor control, some other better place for it?
|
||||
km.x_max = _screenWidth * _scaleFactor - 1;
|
||||
km.y_max = effectiveScreenHeight() - 1;
|
||||
km.delay_time = 25;
|
||||
km.last_time = 0;
|
||||
_km.x_max = _screenWidth * _scaleFactor - 1;
|
||||
_km.y_max = effectiveScreenHeight() - 1;
|
||||
_km.delay_time = 25;
|
||||
_km.last_time = 0;
|
||||
}
|
||||
|
||||
void OSystem_SDL::unload_gfx_mode() {
|
||||
void OSystem_SDL::unloadGFXMode() {
|
||||
if (_screen) {
|
||||
SDL_FreeSurface(_screen);
|
||||
_screen = NULL;
|
||||
@ -335,7 +335,7 @@ void OSystem_SDL::unload_gfx_mode() {
|
||||
#endif
|
||||
}
|
||||
|
||||
void OSystem_SDL::hotswap_gfx_mode() {
|
||||
void OSystem_SDL::hotswapGFXMode() {
|
||||
if (!_screen)
|
||||
return;
|
||||
|
||||
@ -353,7 +353,7 @@ void OSystem_SDL::hotswap_gfx_mode() {
|
||||
#endif
|
||||
|
||||
// Setup the new GFX mode
|
||||
load_gfx_mode();
|
||||
loadGFXMode();
|
||||
|
||||
// reset palette
|
||||
SDL_SetColors(_screen, _currentPalette, 0, 256);
|
||||
@ -399,7 +399,7 @@ void OSystem_SDL::internUpdateScreen() {
|
||||
}
|
||||
|
||||
// Make sure the mouse is drawn, if it should be drawn.
|
||||
draw_mouse();
|
||||
drawMouse();
|
||||
|
||||
// Check whether the palette was changed in the meantime and update the
|
||||
// screen surface accordingly.
|
||||
@ -435,25 +435,24 @@ void OSystem_SDL::internUpdateScreen() {
|
||||
|
||||
// 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;
|
||||
_numDirtyRects = 1;
|
||||
_dirtyRectList[0].x = 0;
|
||||
_dirtyRectList[0].y = 0;
|
||||
_dirtyRectList[0].w = _screenWidth;
|
||||
_dirtyRectList[0].h = _screenHeight;
|
||||
}
|
||||
|
||||
// Only draw anything if necessary
|
||||
if (_num_dirty_rects > 0) {
|
||||
if (_numDirtyRects > 0) {
|
||||
|
||||
SDL_Rect *r;
|
||||
SDL_Rect dst;
|
||||
uint32 srcPitch, dstPitch;
|
||||
SDL_Rect *last_rect = _dirty_rect_list + _num_dirty_rects;
|
||||
SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
|
||||
|
||||
if (_scalerProc == Normal1x && !_adjustAspectRatio) {
|
||||
SDL_Surface *target = _overlayVisible ? _tmpscreen : _screen;
|
||||
for (r = _dirty_rect_list; r != last_rect; ++r) {
|
||||
for (r = _dirtyRectList; r != lastRect; ++r) {
|
||||
dst = *r;
|
||||
|
||||
if (_overlayVisible) {
|
||||
@ -467,7 +466,7 @@ void OSystem_SDL::internUpdateScreen() {
|
||||
}
|
||||
} else {
|
||||
if (!_overlayVisible) {
|
||||
for (r = _dirty_rect_list; r != last_rect; ++r) {
|
||||
for (r = _dirtyRectList; r != lastRect; ++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.
|
||||
@ -482,7 +481,7 @@ void OSystem_SDL::internUpdateScreen() {
|
||||
srcPitch = _tmpscreen->pitch;
|
||||
dstPitch = _hwscreen->pitch;
|
||||
|
||||
for (r = _dirty_rect_list; r != last_rect; ++r) {
|
||||
for (r = _dirtyRectList; r != lastRect; ++r) {
|
||||
register int dst_y = r->y + _currentShakePos;
|
||||
register int dst_h = 0;
|
||||
register int orig_dst_y = 0;
|
||||
@ -518,8 +517,8 @@ void OSystem_SDL::internUpdateScreen() {
|
||||
// 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 = effectiveScreenHeight();
|
||||
_dirtyRectList[0].y = 0;
|
||||
_dirtyRectList[0].h = effectiveScreenHeight();
|
||||
}
|
||||
|
||||
#ifdef USE_OSD
|
||||
@ -529,19 +528,18 @@ void OSystem_SDL::internUpdateScreen() {
|
||||
#endif
|
||||
|
||||
// Finally, blit all our changes to the screen
|
||||
SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
|
||||
SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
|
||||
}
|
||||
|
||||
_num_dirty_rects = 0;
|
||||
_numDirtyRects = 0;
|
||||
_forceFull = false;
|
||||
}
|
||||
|
||||
bool OSystem_SDL::save_screenshot(const char *filename) {
|
||||
bool OSystem_SDL::saveScreenshot(const char *filename) {
|
||||
assert(_hwscreen != NULL);
|
||||
|
||||
Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
|
||||
SDL_SaveBMP(_hwscreen, filename);
|
||||
return true;
|
||||
return SDL_SaveBMP(_hwscreen, filename) == 0;
|
||||
}
|
||||
|
||||
void OSystem_SDL::setFullscreenMode(bool enable) {
|
||||
@ -559,22 +557,22 @@ void OSystem_SDL::setFullscreenMode(bool enable) {
|
||||
|
||||
Common::StackLock lock(_graphicsMutex);
|
||||
|
||||
if (_full_screen != enable) {
|
||||
if (_fullscreen != enable) {
|
||||
assert(_hwscreen != 0);
|
||||
_full_screen ^= true;
|
||||
_fullscreen ^= true;
|
||||
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
#if defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)
|
||||
// On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse,
|
||||
// before SDL 1.2.6 it always returned -1 (which would indicate a
|
||||
// successful switch). So we simply don't call it at all and use
|
||||
// hotswap_gfx_mode() directly to switch to fullscreen mode.
|
||||
hotswap_gfx_mode();
|
||||
// hotswapGFXMode() directly to switch to fullscreen mode.
|
||||
hotswapGFXMode();
|
||||
#else
|
||||
if (!SDL_WM_ToggleFullScreen(_hwscreen)) {
|
||||
// if ToggleFullScreen fails, achieve the same effect with hotswap gfx mode
|
||||
hotswap_gfx_mode();
|
||||
hotswapGFXMode();
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -604,7 +602,7 @@ void OSystem_SDL::setAspectRatioCorrection(bool enable) {
|
||||
|
||||
//assert(_hwscreen != 0);
|
||||
_adjustAspectRatio ^= true;
|
||||
hotswap_gfx_mode();
|
||||
hotswapGFXMode();
|
||||
|
||||
// Blit everything to the screen
|
||||
internUpdateScreen();
|
||||
@ -638,12 +636,12 @@ void OSystem_SDL::copyRectToScreen(const byte *src, int pitch, int x, int y, int
|
||||
|
||||
Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
|
||||
|
||||
if (((long)src & 3) == 0 && pitch == _screenWidth && x==0 && y==0 &&
|
||||
w==_screenWidth && h==_screenHeight && _mode_flags&DF_WANT_RECT_OPTIM) {
|
||||
if (((long)src & 3) == 0 && pitch == _screenWidth && x == 0 && y == 0 &&
|
||||
w == _screenWidth && h == _screenHeight && _modeFlags & 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(src);
|
||||
addDirtyRgnAuto(src);
|
||||
} else {
|
||||
/* Clip the coordinates */
|
||||
if (x < 0) {
|
||||
@ -669,12 +667,12 @@ void OSystem_SDL::copyRectToScreen(const byte *src, int pitch, int x, int y, int
|
||||
if (w <= 0 || h <= 0)
|
||||
return;
|
||||
|
||||
cksum_valid = false;
|
||||
add_dirty_rect(x, y, w, h);
|
||||
_cksumValid = false;
|
||||
addDirtyRect(x, y, w, h);
|
||||
}
|
||||
|
||||
/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
// Try to lock the screen surface
|
||||
if (SDL_LockSurface(_screen) == -1)
|
||||
@ -697,17 +695,17 @@ void OSystem_SDL::copyRectToScreen(const byte *src, int pitch, int x, int y, int
|
||||
}
|
||||
|
||||
|
||||
void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
|
||||
void OSystem_SDL::addDirtyRect(int x, int y, int w, int h) {
|
||||
if (_forceFull)
|
||||
return;
|
||||
|
||||
if (_num_dirty_rects == NUM_DIRTY_RECT)
|
||||
if (_numDirtyRects == NUM_DIRTY_RECT)
|
||||
_forceFull = true;
|
||||
else {
|
||||
SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++];
|
||||
SDL_Rect *r = &_dirtyRectList[_numDirtyRects++];
|
||||
// Extend the dirty region by 1 pixel for scalers
|
||||
// that "smear" the screen, e.g. 2xSAI
|
||||
if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) {
|
||||
if (_modeFlags & DF_UPDATE_EXPAND_1_PIXEL) {
|
||||
x--;
|
||||
y--;
|
||||
w+=2;
|
||||
@ -743,8 +741,8 @@ void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
|
||||
}
|
||||
|
||||
|
||||
void OSystem_SDL::mk_checksums(const byte *buf) {
|
||||
uint32 *sums = _dirty_checksums;
|
||||
void OSystem_SDL::makeChecksums(const byte *buf) {
|
||||
uint32 *sums = _dirtyChecksums;
|
||||
uint x,y;
|
||||
const uint last_x = (uint)_screenWidth / 8;
|
||||
const uint last_y = (uint)_screenHeight / 8;
|
||||
@ -780,36 +778,36 @@ void OSystem_SDL::mk_checksums(const byte *buf) {
|
||||
}
|
||||
}
|
||||
|
||||
void OSystem_SDL::add_dirty_rgn_auto(const byte *buf) {
|
||||
void OSystem_SDL::addDirtyRgnAuto(const byte *buf) {
|
||||
assert(((long)buf & 3) == 0);
|
||||
|
||||
/* generate a table of the checksums */
|
||||
mk_checksums(buf);
|
||||
makeChecksums(buf);
|
||||
|
||||
if (!cksum_valid) {
|
||||
if (!_cksumValid) {
|
||||
_forceFull = true;
|
||||
cksum_valid = true;
|
||||
_cksumValid = 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;
|
||||
int x, y, w;
|
||||
uint32 *ck = _dirtyChecksums;
|
||||
|
||||
for(y = 0; y!=_screenHeight / 8; y++) {
|
||||
for(x = 0; x!=_screenWidth / 8; x++, ck++) {
|
||||
if (ck[0] != ck[CKSUM_NUM]) {
|
||||
for(y = 0; y != _screenHeight / 8; y++) {
|
||||
for(x = 0; x != _screenWidth / 8; x++, ck++) {
|
||||
if (ck[0] != ck[_cksumNum]) {
|
||||
/* 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];
|
||||
ck[w + _cksumNum] = ck[w];
|
||||
w++;
|
||||
} while (x + w != _screenWidth / 8 && ck[w] != ck[w + CKSUM_NUM]);
|
||||
} while (x + w != _screenWidth / 8 && ck[w] != ck[w + _cksumNum]);
|
||||
|
||||
add_dirty_rect(x * 8, y * 8, w * 8, 8);
|
||||
addDirtyRect(x * 8, y * 8, w * 8, 8);
|
||||
|
||||
if (_forceFull)
|
||||
goto get_out;
|
||||
@ -819,7 +817,7 @@ void OSystem_SDL::add_dirty_rgn_auto(const byte *buf) {
|
||||
} else {
|
||||
get_out:;
|
||||
/* Copy old checksums to new */
|
||||
memcpy(_dirty_checksums + CKSUM_NUM, _dirty_checksums, CKSUM_NUM * sizeof(uint32));
|
||||
memcpy(_dirtyChecksums + _cksumNum, _dirtyChecksums, _cksumNum * sizeof(uint32));
|
||||
}
|
||||
}
|
||||
|
||||
@ -864,7 +862,7 @@ void OSystem_SDL::showOverlay() {
|
||||
assert (_transactionMode == kTransactionNone);
|
||||
|
||||
// hide the mouse
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
_overlayVisible = true;
|
||||
clearOverlay();
|
||||
@ -874,7 +872,7 @@ void OSystem_SDL::hideOverlay() {
|
||||
assert (_transactionMode == kTransactionNone);
|
||||
|
||||
// hide the mouse
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
_overlayVisible = false;
|
||||
_forceFull = true;
|
||||
@ -889,7 +887,7 @@ void OSystem_SDL::clearOverlay() {
|
||||
Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
|
||||
|
||||
// hide the mouse
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
// Clear the overlay by making the game screen "look through" everywhere.
|
||||
SDL_Rect src, dst;
|
||||
@ -913,7 +911,7 @@ void OSystem_SDL::grabOverlay(OverlayColor *buf, int pitch) {
|
||||
return;
|
||||
|
||||
// hide the mouse
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
if (SDL_LockSurface(_tmpscreen) == -1)
|
||||
error("SDL_LockSurface failed: %s", SDL_GetError());
|
||||
@ -962,11 +960,11 @@ void OSystem_SDL::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, i
|
||||
return;
|
||||
|
||||
// Mark the modified region as dirty
|
||||
cksum_valid = false;
|
||||
add_dirty_rect(x, y, w, h);
|
||||
_cksumValid = false;
|
||||
addDirtyRect(x, y, w, h);
|
||||
|
||||
/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
if (SDL_LockSurface(_tmpscreen) == -1)
|
||||
error("SDL_LockSurface failed: %s", SDL_GetError());
|
||||
@ -1002,16 +1000,16 @@ bool OSystem_SDL::showMouse(bool visible) {
|
||||
_mouseVisible = visible;
|
||||
|
||||
if (visible)
|
||||
draw_mouse();
|
||||
drawMouse();
|
||||
else
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
return last;
|
||||
}
|
||||
|
||||
void OSystem_SDL::set_mouse_pos(int x, int y) {
|
||||
void OSystem_SDL::setMousePos(int x, int y) {
|
||||
if (x != _mouseCurState.x || y != _mouseCurState.y) {
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
_mouseCurState.x = x;
|
||||
_mouseCurState.y = y;
|
||||
updateScreen();
|
||||
@ -1023,19 +1021,19 @@ void OSystem_SDL::warpMouse(int x, int y) {
|
||||
SDL_WarpMouse(x * _scaleFactor, y * _scaleFactor);
|
||||
|
||||
// SDL_WarpMouse() generates a mouse movement event, so
|
||||
// set_mouse_pos() would be called eventually. However, the
|
||||
// setMousePos() would be called eventually. However, the
|
||||
// cannon script in CoMI calls this function twice each time
|
||||
// the cannon is reloaded. Unless we update the mouse position
|
||||
// immediately the second call is ignored, causing the cannon
|
||||
// to change its aim.
|
||||
|
||||
set_mouse_pos(x, y);
|
||||
setMousePos(x, y);
|
||||
}
|
||||
}
|
||||
|
||||
void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor) {
|
||||
|
||||
undraw_mouse();
|
||||
undrawMouse();
|
||||
|
||||
assert(w <= MAX_MOUSE_W);
|
||||
assert(h <= MAX_MOUSE_H);
|
||||
@ -1045,10 +1043,9 @@ void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x,
|
||||
_mouseHotspotX = hotspot_x;
|
||||
_mouseHotspotY = hotspot_y;
|
||||
|
||||
_mouseKeycolor = keycolor;
|
||||
_mouseKeyColor = keycolor;
|
||||
|
||||
if (_mouseData)
|
||||
free(_mouseData);
|
||||
free(_mouseData);
|
||||
|
||||
_mouseData = (byte *)malloc(w * h);
|
||||
memcpy(_mouseData, buf, w * h);
|
||||
@ -1061,7 +1058,7 @@ void OSystem_SDL::toggleMouseGrab() {
|
||||
SDL_WM_GrabInput(SDL_GRAB_OFF);
|
||||
}
|
||||
|
||||
void OSystem_SDL::draw_mouse() {
|
||||
void OSystem_SDL::drawMouse() {
|
||||
if (_mouseDrawn || !_mouseVisible)
|
||||
return;
|
||||
|
||||
@ -1098,7 +1095,7 @@ void OSystem_SDL::draw_mouse() {
|
||||
error("SDL_LockSurface failed: %s", SDL_GetError());
|
||||
|
||||
// Mark as dirty
|
||||
add_dirty_rect(x, y, w, h);
|
||||
addDirtyRect(x, y, w, h);
|
||||
|
||||
if (!_overlayVisible) {
|
||||
byte *bak = _mouseBackup; // Surface used to backup the area obscured by the mouse
|
||||
@ -1110,7 +1107,7 @@ void OSystem_SDL::draw_mouse() {
|
||||
while (width > 0) {
|
||||
*bak++ = *dst;
|
||||
color = *src++;
|
||||
if (color != _mouseKeycolor) // transparent, don't draw
|
||||
if (color != _mouseKeyColor) // transparent, don't draw
|
||||
*dst = color;
|
||||
dst++;
|
||||
width--;
|
||||
@ -1149,7 +1146,7 @@ void OSystem_SDL::draw_mouse() {
|
||||
_mouseDrawn = true;
|
||||
}
|
||||
|
||||
void OSystem_SDL::undraw_mouse() {
|
||||
void OSystem_SDL::undrawMouse() {
|
||||
assert (_transactionMode == kTransactionNone);
|
||||
|
||||
if (!_mouseDrawn)
|
||||
@ -1187,7 +1184,7 @@ void OSystem_SDL::undraw_mouse() {
|
||||
if (!_overlayVisible) {
|
||||
byte *dst, *bak = _mouseBackup;
|
||||
|
||||
// No need to do clipping here, since draw_mouse() did that already
|
||||
// No need to do clipping here, since drawMouse() 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) {
|
||||
@ -1200,7 +1197,7 @@ void OSystem_SDL::undraw_mouse() {
|
||||
byte *dst;
|
||||
uint16 *bak = (uint16 *)_mouseBackup;
|
||||
|
||||
// No need to do clipping here, since draw_mouse() did that already
|
||||
// No need to do clipping here, since drawMouse() did that already
|
||||
dst = (byte *)_tmpscreen->pixels + (old_mouse_y + 1) * _tmpscreen->pitch + (old_mouse_x + 1) * 2;
|
||||
for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _tmpscreen->pitch) {
|
||||
for (x = 0; x < old_mouse_w; ++x) {
|
||||
@ -1209,7 +1206,7 @@ void OSystem_SDL::undraw_mouse() {
|
||||
}
|
||||
}
|
||||
|
||||
add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
|
||||
addDirtyRect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
|
||||
|
||||
SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
|
||||
}
|
||||
|
||||
@ -160,7 +160,7 @@ public:
|
||||
#endif
|
||||
|
||||
protected:
|
||||
void init_intern();
|
||||
void initIntern();
|
||||
|
||||
#ifdef USE_OSD
|
||||
SDL_Surface *_osdSurface;
|
||||
@ -190,8 +190,8 @@ protected:
|
||||
|
||||
// CD Audio
|
||||
SDL_CD *_cdrom;
|
||||
int cd_track, cd_num_loops, cd_start_frame, cd_duration;
|
||||
Uint32 cd_end_time, cd_stop_time;
|
||||
int _cdTrack, _cdNumLoops, _cdStartFrame, _cdDuration;
|
||||
uint32 _cdEndTime, _cdStopTime;
|
||||
|
||||
enum {
|
||||
DF_WANT_RECT_OPTIM = 1 << 0,
|
||||
@ -217,14 +217,17 @@ protected:
|
||||
bool arChanged;
|
||||
} _transactionDetails;
|
||||
|
||||
bool _forceFull; // Force full redraw on next updateScreen
|
||||
/** Force full redraw on next updateScreen */
|
||||
bool _forceFull;
|
||||
ScalerProc *_scalerProc;
|
||||
int _scalerType;
|
||||
int _scalerType;
|
||||
int _scaleFactor;
|
||||
int _mode;
|
||||
int _transactionMode;
|
||||
bool _full_screen;
|
||||
uint32 _mode_flags;
|
||||
bool _fullscreen;
|
||||
|
||||
/** Current video mode flags (see DF_* constants) */
|
||||
uint32 _modeFlags;
|
||||
bool _modeChanged;
|
||||
|
||||
/** True if aspect ratio correction is enabled. */
|
||||
@ -238,25 +241,25 @@ protected:
|
||||
MAX_SCALING = 3
|
||||
};
|
||||
|
||||
// Dirty rect managment
|
||||
SDL_Rect _dirty_rect_list[NUM_DIRTY_RECT];
|
||||
int _num_dirty_rects;
|
||||
uint32 *_dirty_checksums;
|
||||
bool cksum_valid;
|
||||
int CKSUM_NUM;
|
||||
// Dirty rect management
|
||||
SDL_Rect _dirtyRectList[NUM_DIRTY_RECT];
|
||||
int _numDirtyRects;
|
||||
uint32 *_dirtyChecksums;
|
||||
bool _cksumValid;
|
||||
int _cksumNum;
|
||||
|
||||
// Keyboard mouse emulation
|
||||
struct KbdMouse {
|
||||
int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;
|
||||
uint32 last_time, delay_time, x_down_time, y_down_time;
|
||||
} km;
|
||||
};
|
||||
|
||||
struct MousePos {
|
||||
int16 x, y, w, h;
|
||||
MousePos() : x(0), y(0), w(0), h(0) {}
|
||||
};
|
||||
|
||||
// mouse
|
||||
KbdMouse _km;
|
||||
bool _mouseVisible;
|
||||
bool _mouseDrawn;
|
||||
byte *_mouseData;
|
||||
@ -264,7 +267,7 @@ protected:
|
||||
MousePos _mouseCurState;
|
||||
int16 _mouseHotspotX;
|
||||
int16 _mouseHotspotY;
|
||||
byte _mouseKeycolor;
|
||||
byte _mouseKeyColor;
|
||||
|
||||
// joystick
|
||||
SDL_Joystick *_joystick;
|
||||
@ -284,35 +287,34 @@ protected:
|
||||
MutexRef _graphicsMutex;
|
||||
|
||||
|
||||
void add_dirty_rgn_auto(const byte *buf);
|
||||
void mk_checksums(const byte *buf);
|
||||
void addDirtyRgnAuto(const byte *buf);
|
||||
void makeChecksums(const byte *buf);
|
||||
|
||||
void addDirtyRect(int x, int y, int w, int h);
|
||||
|
||||
virtual void add_dirty_rect(int x, int y, int w, int h);
|
||||
|
||||
void draw_mouse();
|
||||
void undraw_mouse();
|
||||
void drawMouse();
|
||||
void undrawMouse();
|
||||
|
||||
/** Set the position of the virtual mouse cursor. */
|
||||
void set_mouse_pos(int x, int y);
|
||||
void setMousePos(int x, int y);
|
||||
void fillMouseEvent(Event &event, int x, int y);
|
||||
void toggleMouseGrab();
|
||||
|
||||
void internUpdateScreen();
|
||||
|
||||
virtual void internUpdateScreen();
|
||||
|
||||
virtual void load_gfx_mode();
|
||||
virtual void unload_gfx_mode();
|
||||
virtual void hotswap_gfx_mode();
|
||||
void loadGFXMode();
|
||||
void unloadGFXMode();
|
||||
void hotswapGFXMode();
|
||||
|
||||
void setFullscreenMode(bool enable);
|
||||
void setAspectRatioCorrection(bool enable);
|
||||
|
||||
bool save_screenshot(const char *filename);
|
||||
bool saveScreenshot(const char *filename);
|
||||
|
||||
int effectiveScreenHeight() { return (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor; }
|
||||
int effectiveScreenHeight() const { return (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor; }
|
||||
|
||||
void setup_icon();
|
||||
void kbd_mouse();
|
||||
void init_joystick(int joystick_num) { _joystick = SDL_JoystickOpen(joystick_num); }
|
||||
void setupIcon();
|
||||
void handleKbdMouse();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -35,7 +35,7 @@ OSystem *OSystem_SDL_create() {
|
||||
return new OSystem_SDL();
|
||||
}
|
||||
|
||||
void OSystem_SDL::init_intern() {
|
||||
void OSystem_SDL::initIntern() {
|
||||
|
||||
int joystick_num = ConfMan.getInt("joystick_num");
|
||||
uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
|
||||
@ -61,33 +61,33 @@ void OSystem_SDL::init_intern() {
|
||||
// Enable unicode support if possible
|
||||
SDL_EnableUNICODE(1);
|
||||
|
||||
cksum_valid = false;
|
||||
_cksumValid = false;
|
||||
#ifndef _WIN32_WCE
|
||||
_mode = GFX_DOUBLESIZE;
|
||||
_scaleFactor = 2;
|
||||
_scalerProc = Normal2x;
|
||||
_full_screen = ConfMan.getBool("fullscreen");
|
||||
_fullscreen = ConfMan.getBool("fullscreen");
|
||||
_adjustAspectRatio = ConfMan.getBool("aspect_ratio");
|
||||
#else
|
||||
_mode = GFX_NORMAL;
|
||||
_scaleFactor = 1;
|
||||
_scalerProc = Normal1x;
|
||||
_full_screen = true;
|
||||
_fullscreen = true;
|
||||
_adjustAspectRatio = false;
|
||||
#endif
|
||||
_scalerType = 0;
|
||||
_mode_flags = 0;
|
||||
_modeFlags = 0;
|
||||
|
||||
|
||||
#ifndef MACOSX // Don't set icon on OS X, as we use a nicer external icon there
|
||||
// Setup the icon
|
||||
setup_icon();
|
||||
setupIcon();
|
||||
#endif
|
||||
|
||||
// enable joystick
|
||||
if (joystick_num > -1 && SDL_NumJoysticks() > 0) {
|
||||
printf("Using joystick: %s\n", SDL_JoystickName(0));
|
||||
init_joystick(joystick_num);
|
||||
_joystick = SDL_JoystickOpen(joystick_num);
|
||||
}
|
||||
}
|
||||
|
||||
@ -99,9 +99,10 @@ OSystem_SDL::OSystem_SDL()
|
||||
_hwscreen(0), _screen(0), _screenWidth(0), _screenHeight(0),
|
||||
_tmpscreen(0), _overlayVisible(false),
|
||||
_samplesPerSec(0),
|
||||
_cdrom(0), _scalerProc(0), _modeChanged(false), _dirty_checksums(0),
|
||||
_cdrom(0), _scalerProc(0), _modeChanged(false), _dirtyChecksums(0),
|
||||
_mouseVisible(false), _mouseDrawn(false), _mouseData(0),
|
||||
_mouseHotspotX(0), _mouseHotspotY(0),
|
||||
_joystick(0),
|
||||
_currentShakePos(0), _newShakePos(0),
|
||||
_paletteDirtyStart(0), _paletteDirtyEnd(0),
|
||||
_graphicsMutex(0), _transactionMode(kTransactionNone) {
|
||||
@ -113,22 +114,17 @@ OSystem_SDL::OSystem_SDL()
|
||||
_mouseBackup = (byte *)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
|
||||
|
||||
// reset mouse state
|
||||
memset(&km, 0, sizeof(km));
|
||||
memset(&_km, 0, sizeof(_km));
|
||||
memset(&_mouseCurState, 0, sizeof(_mouseCurState));
|
||||
|
||||
init_intern();
|
||||
initIntern();
|
||||
}
|
||||
|
||||
OSystem_SDL::~OSystem_SDL() {
|
||||
// unload_gfx_mode();
|
||||
|
||||
if (_dirty_checksums)
|
||||
free(_dirty_checksums);
|
||||
free(_dirtyChecksums);
|
||||
free(_currentPalette);
|
||||
free(_mouseBackup);
|
||||
deleteMutex(_graphicsMutex);
|
||||
|
||||
SDL_ShowCursor(SDL_ENABLE);
|
||||
SDL_Quit();
|
||||
free(_mouseData);
|
||||
}
|
||||
|
||||
uint32 OSystem_SDL::getMillis() {
|
||||
@ -164,9 +160,9 @@ void OSystem_SDL::setFeatureState(Feature f, bool enable) {
|
||||
break;
|
||||
case kFeatureAutoComputeDirtyRects:
|
||||
if (enable)
|
||||
_mode_flags |= DF_WANT_RECT_OPTIM;
|
||||
_modeFlags |= DF_WANT_RECT_OPTIM;
|
||||
else
|
||||
_mode_flags &= ~DF_WANT_RECT_OPTIM;
|
||||
_modeFlags &= ~DF_WANT_RECT_OPTIM;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
@ -178,30 +174,33 @@ bool OSystem_SDL::getFeatureState(Feature f) {
|
||||
|
||||
switch (f) {
|
||||
case kFeatureFullscreenMode:
|
||||
return _full_screen;
|
||||
return _fullscreen;
|
||||
case kFeatureAspectRatioCorrection:
|
||||
return _adjustAspectRatio;
|
||||
case kFeatureAutoComputeDirtyRects:
|
||||
return _mode_flags & DF_WANT_RECT_OPTIM;
|
||||
return _modeFlags & DF_WANT_RECT_OPTIM;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void OSystem_SDL::quit() {
|
||||
if(_cdrom) {
|
||||
if (_cdrom) {
|
||||
SDL_CDStop(_cdrom);
|
||||
SDL_CDClose(_cdrom);
|
||||
}
|
||||
unload_gfx_mode();
|
||||
unloadGFXMode();
|
||||
deleteMutex(_graphicsMutex);
|
||||
|
||||
if (_joystick)
|
||||
SDL_JoystickClose(_joystick);
|
||||
SDL_ShowCursor(SDL_ENABLE);
|
||||
SDL_Quit();
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
||||
void OSystem_SDL::setup_icon() {
|
||||
void OSystem_SDL::setupIcon() {
|
||||
int w, h, ncols, nbytes, i;
|
||||
unsigned int rgba[256], icon[32 * 32];
|
||||
unsigned char mask[32][4];
|
||||
@ -327,9 +326,9 @@ bool OSystem_SDL::openCD(int drive) {
|
||||
if (!_cdrom) {
|
||||
warning("Couldn't open drive: %s", SDL_GetError());
|
||||
} else {
|
||||
cd_num_loops = 0;
|
||||
cd_stop_time = 0;
|
||||
cd_end_time = 0;
|
||||
_cdNumLoops = 0;
|
||||
_cdStopTime = 0;
|
||||
_cdEndTime = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@ -337,8 +336,8 @@ bool OSystem_SDL::openCD(int drive) {
|
||||
}
|
||||
|
||||
void OSystem_SDL::stopCD() { /* Stop CD Audio in 1/10th of a second */
|
||||
cd_stop_time = SDL_GetTicks() + 100;
|
||||
cd_num_loops = 0;
|
||||
_cdStopTime = SDL_GetTicks() + 100;
|
||||
_cdNumLoops = 0;
|
||||
}
|
||||
|
||||
void OSystem_SDL::playCD(int track, int num_loops, int start_frame, int duration) {
|
||||
@ -351,55 +350,55 @@ void OSystem_SDL::playCD(int track, int num_loops, int start_frame, int duration
|
||||
if (duration > 0)
|
||||
duration += 5;
|
||||
|
||||
cd_track = track;
|
||||
cd_num_loops = num_loops;
|
||||
cd_start_frame = start_frame;
|
||||
_cdTrack = track;
|
||||
_cdNumLoops = num_loops;
|
||||
_cdStartFrame = start_frame;
|
||||
|
||||
SDL_CDStatus(_cdrom);
|
||||
if (start_frame == 0 && duration == 0)
|
||||
SDL_CDPlayTracks(_cdrom, track, 0, 1, 0);
|
||||
else
|
||||
SDL_CDPlayTracks(_cdrom, track, start_frame, 0, duration);
|
||||
cd_duration = duration;
|
||||
cd_stop_time = 0;
|
||||
cd_end_time = SDL_GetTicks() + _cdrom->track[track].length * 1000 / CD_FPS;
|
||||
_cdDuration = duration;
|
||||
_cdStopTime = 0;
|
||||
_cdEndTime = SDL_GetTicks() + _cdrom->track[track].length * 1000 / CD_FPS;
|
||||
}
|
||||
|
||||
bool OSystem_SDL::pollCD() {
|
||||
if (!_cdrom)
|
||||
return false;
|
||||
|
||||
return (cd_num_loops != 0 && (SDL_GetTicks() < cd_end_time || SDL_CDStatus(_cdrom) != CD_STOPPED));
|
||||
return (_cdNumLoops != 0 && (SDL_GetTicks() < _cdEndTime || SDL_CDStatus(_cdrom) != CD_STOPPED));
|
||||
}
|
||||
|
||||
void OSystem_SDL::updateCD() {
|
||||
if (!_cdrom)
|
||||
return;
|
||||
|
||||
if (cd_stop_time != 0 && SDL_GetTicks() >= cd_stop_time) {
|
||||
if (_cdStopTime != 0 && SDL_GetTicks() >= _cdStopTime) {
|
||||
SDL_CDStop(_cdrom);
|
||||
cd_num_loops = 0;
|
||||
cd_stop_time = 0;
|
||||
_cdNumLoops = 0;
|
||||
_cdStopTime = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
if (cd_num_loops == 0 || SDL_GetTicks() < cd_end_time)
|
||||
if (_cdNumLoops == 0 || SDL_GetTicks() < _cdEndTime)
|
||||
return;
|
||||
|
||||
if (cd_num_loops != 1 && SDL_CDStatus(_cdrom) != CD_STOPPED) {
|
||||
if (_cdNumLoops != 1 && SDL_CDStatus(_cdrom) != CD_STOPPED) {
|
||||
// Wait another second for it to be done
|
||||
cd_end_time += 1000;
|
||||
_cdEndTime += 1000;
|
||||
return;
|
||||
}
|
||||
|
||||
if (cd_num_loops > 0)
|
||||
cd_num_loops--;
|
||||
if (_cdNumLoops > 0)
|
||||
_cdNumLoops--;
|
||||
|
||||
if (cd_num_loops != 0) {
|
||||
if (cd_start_frame == 0 && cd_duration == 0)
|
||||
SDL_CDPlayTracks(_cdrom, cd_track, 0, 1, 0);
|
||||
if (_cdNumLoops != 0) {
|
||||
if (_cdStartFrame == 0 && _cdDuration == 0)
|
||||
SDL_CDPlayTracks(_cdrom, _cdTrack, 0, 1, 0);
|
||||
else
|
||||
SDL_CDPlayTracks(_cdrom, cd_track, cd_start_frame, 0, cd_duration);
|
||||
cd_end_time = SDL_GetTicks() + _cdrom->track[cd_track].length * 1000 / CD_FPS;
|
||||
SDL_CDPlayTracks(_cdrom, _cdTrack, _cdStartFrame, 0, _cdDuration);
|
||||
_cdEndTime = SDL_GetTicks() + _cdrom->track[_cdTrack].length * 1000 / CD_FPS;
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user