void DINGUXSdlGraphicsManager::setGraphicsModeIntern() {
Common::StackLock lock(_graphicsMutex);
ScalerProc *newScalerProc = 0;
switch (_videoMode.mode) {
case GFX_NORMAL:
newScalerProc = Normal1x;
break;
#ifdef USE_SCALERS
case GFX_HALF:
newScalerProc = DownscaleAllByHalf;
break;
#endif
default:
error("Unknown gfx mode %d", _videoMode.mode);
}
_scalerProc = newScalerProc;
if (!_screen || !_hwscreen)
return;
// Blit everything to the screen
_forceFull = true;
// Even if the old and new scale factors are the same, we may have a
// different scaler for the cursor now.
blitCursor();
}
void DINGUXSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
switch (f) {
case OSystem::kFeatureAspectRatioCorrection:
setAspectRatioCorrection(enable);
break;
case OSystem::kFeatureCursorPalette:
_cursorPaletteDisabled = !enable;
blitCursor();
break;
default:
break;
}
}
void Draw::blitInvalidated() {
if (_noInvalidated57 &&
((_vm->_global->_videoMode == 5) || (_vm->_global->_videoMode == 7)))
return;
if (_cursorIndex == 4)
blitCursor();
if (_vm->_inter->_terminate)
return;
if (_noInvalidated && !_applyPal)
return;
if (_vm->isTrueColor())
_applyPal = false;
if (_noInvalidated) {
setPalette();
_applyPal = false;
return;
}
_showCursor = (_showCursor & ~2) | ((_showCursor & 1) << 1);
if (_applyPal) {
clearPalette();
forceBlit();
setPalette();
_invalidatedCount = 0;
_noInvalidated = true;
_applyPal = false;
return;
}
_vm->_video->_doRangeClamp = false;
for (int i = 0; i < _invalidatedCount; i++) {
_frontSurface->blit(*_backSurface,
_invalidatedLefts[i], _invalidatedTops[i],
_invalidatedRights[i], _invalidatedBottoms[i],
_invalidatedLefts[i], _invalidatedTops[i]);
_vm->_video->dirtyRectsAdd(_invalidatedLefts[i], _invalidatedTops[i],
_invalidatedRights[i], _invalidatedBottoms[i]);
}
_vm->_video->_doRangeClamp = true;
_invalidatedCount = 0;
_noInvalidated = true;
_applyPal = false;
}
void OSystem_SDL::setCursorPalette(const byte *colors, uint start, uint num) {
assert(colors);
const byte *b = colors;
uint i;
SDL_Color *base = _cursorPalette + start;
for (i = 0; i < num; i++) {
base[i].r = b[0];
base[i].g = b[1];
base[i].b = b[2];
b += 4;
}
_cursorPaletteDisabled = false;
blitCursor();
}
void OSystem_SDL::hotswapGFXMode() {
if (!_screen)
return;
// Keep around the old _screen & _overlayscreen so we can restore the screen data
// after the mode switch.
SDL_Surface *old_screen = _screen;
SDL_Surface *old_overlayscreen = _overlayscreen;
// Release the HW screen surface
SDL_FreeSurface(_hwscreen);
SDL_FreeSurface(_tmpscreen);
SDL_FreeSurface(_tmpscreen2);
#ifdef USE_OSD
// Release the OSD surface
SDL_FreeSurface(_osdSurface);
#endif
// Setup the new GFX mode
loadGFXMode();
// reset palette
SDL_SetColors(_screen, _currentPalette, 0, 256);
// Restore old screen content
SDL_BlitSurface(old_screen, NULL, _screen, NULL);
SDL_BlitSurface(old_overlayscreen, NULL, _overlayscreen, NULL);
// Free the old surfaces
SDL_FreeSurface(old_screen);
SDL_FreeSurface(old_overlayscreen);
// Update cursor to new scale
blitCursor();
// Blit everything to the screen
internUpdateScreen();
// Make sure that an EVENT_SCREEN_CHANGED gets sent later
_modeChanged = true;
}
void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorTargetScale) {
if (w == 0 || h == 0)
return;
_mouseCurState.hotX = hotspot_x;
_mouseCurState.hotY = hotspot_y;
_mouseKeyColor = keycolor;
_cursorTargetScale = cursorTargetScale;
if (_mouseCurState.w != (int)w || _mouseCurState.h != (int)h) {
_mouseCurState.w = w;
_mouseCurState.h = h;
if (_mouseOrigSurface)
SDL_FreeSurface(_mouseOrigSurface);
// Allocate bigger surface because AdvMame2x adds black pixel at [0,0]
_mouseOrigSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
_mouseCurState.w + 2,
_mouseCurState.h + 2,
16,
_hwscreen->format->Rmask,
_hwscreen->format->Gmask,
_hwscreen->format->Bmask,
_hwscreen->format->Amask);
if (_mouseOrigSurface == NULL)
error("allocating _mouseOrigSurface failed");
SDL_SetColorKey(_mouseOrigSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
}
free(_mouseData);
_mouseData = (byte *)malloc(w * h);
memcpy(_mouseData, buf, w * h);
blitCursor();
}
void OSystem_SDL::setPalette(const byte *colors, uint start, uint num) {
assert(colors);
const byte *b = colors;
uint i;
SDL_Color *base = _currentPalette + start;
for (i = 0; i < num; i++) {
base[i].r = b[0];
base[i].g = b[1];
base[i].b = b[2];
b += 4;
}
if (start < _paletteDirtyStart)
_paletteDirtyStart = start;
if (start + num > _paletteDirtyEnd)
_paletteDirtyEnd = start + num;
// Some games blink cursors with palette
if (_cursorPaletteDisabled)
blitCursor();
}
void Draw_v1::animateCursor(int16 cursor) {
int16 cursorIndex = cursor;
int16 newX = 0, newY = 0;
uint16 hotspotX = 0, hotspotY = 0;
_showCursor = 2;
if (cursorIndex == -1) {
cursorIndex =
_vm->_game->_hotspots->findCursor(_vm->_global->_inter_mouseX,
_vm->_global->_inter_mouseY);
if (_cursorAnimLow[cursorIndex] == -1)
cursorIndex = 1;
}
if (_cursorAnimLow[cursorIndex] != -1) {
if (cursorIndex == _cursorIndex) {
if (_cursorAnimDelays[_cursorIndex] != 0 &&
_cursorAnimDelays[_cursorIndex] * 10 +
_cursorTimeKey <= _vm->_util->getTimeKey()) {
_cursorAnim++;
_cursorTimeKey = _vm->_util->getTimeKey();
} else {
if (_noInvalidated && (_vm->_global->_inter_mouseX == _cursorX) &&
(_vm->_global->_inter_mouseY == _cursorY)) {
_vm->_video->waitRetrace();
return;
}
}
} else {
_cursorIndex = cursorIndex;
if (_cursorAnimDelays[_cursorIndex] != 0) {
_cursorAnim =
_cursorAnimLow[_cursorIndex];
_cursorTimeKey = _vm->_util->getTimeKey();
} else {
_cursorAnim = _cursorIndex;
}
}
if (_cursorAnimDelays[_cursorIndex] != 0 &&
(_cursorAnimHigh[_cursorIndex] < _cursorAnim ||
_cursorAnimLow[_cursorIndex] >
_cursorAnim)) {
_cursorAnim = _cursorAnimLow[_cursorIndex];
}
newX = _vm->_global->_inter_mouseX;
newY = _vm->_global->_inter_mouseY;
if (_cursorHotspotXVar != -1) {
newX -= hotspotX = (uint16) VAR(_cursorIndex + _cursorHotspotXVar);
newY -= hotspotY = (uint16) VAR(_cursorIndex + _cursorHotspotYVar);
}
_scummvmCursor->clear();
_scummvmCursor->blit(*_cursorSprites,
cursorIndex * _cursorWidth, 0,
(cursorIndex + 1) * _cursorWidth - 1,
_cursorHeight - 1, 0, 0);
CursorMan.replaceCursor(_scummvmCursor->getData(),
_cursorWidth, _cursorHeight, hotspotX, hotspotY, 0, 1, &_vm->getPixelFormat());
if (_frontSurface != _backSurface) {
_showCursor = 3;
if (!_noInvalidated) {
int16 tmp = _cursorIndex;
_cursorIndex = -1;
blitInvalidated();
_cursorIndex = tmp;
} else {
_vm->_video->waitRetrace();
if (MIN(newY, _cursorY) < 50)
_vm->_util->delay(5);
_showCursor = 0;
}
}
} else
blitCursor();
_cursorX = newX;
_cursorY = newY;
}
bool OSystem_SDL::setGraphicsMode(int mode) {
Common::StackLock lock(_graphicsMutex);
int newScaleFactor = 1;
ScalerProc *newScalerProc;
switch(mode) {
case GFX_NORMAL:
newScaleFactor = 1;
newScalerProc = Normal1x;
break;
#ifndef DISABLE_SCALERS
case GFX_DOUBLESIZE:
newScaleFactor = 2;
newScalerProc = Normal2x;
break;
case GFX_TRIPLESIZE:
newScaleFactor = 3;
newScalerProc = Normal3x;
break;
case GFX_2XSAI:
newScaleFactor = 2;
newScalerProc = _2xSaI;
break;
case GFX_SUPER2XSAI:
newScaleFactor = 2;
newScalerProc = Super2xSaI;
break;
case GFX_SUPEREAGLE:
newScaleFactor = 2;
newScalerProc = SuperEagle;
break;
case GFX_ADVMAME2X:
newScaleFactor = 2;
newScalerProc = AdvMame2x;
break;
case GFX_ADVMAME3X:
newScaleFactor = 3;
newScalerProc = AdvMame3x;
break;
#ifndef DISABLE_HQ_SCALERS
case GFX_HQ2X:
newScaleFactor = 2;
newScalerProc = HQ2x;
break;
case GFX_HQ3X:
newScaleFactor = 3;
newScalerProc = HQ3x;
break;
#endif
case GFX_TV2X:
newScaleFactor = 2;
newScalerProc = TV2x;
break;
case GFX_DOTMATRIX:
newScaleFactor = 2;
newScalerProc = DotMatrix;
break;
#endif // DISABLE_SCALERS
default:
warning("unknown gfx mode %d", mode);
return false;
}
_transactionDetails.normal1xScaler = (mode == GFX_NORMAL);
_mode = mode;
_scalerProc = newScalerProc;
if (_transactionMode == kTransactionActive) {
_transactionDetails.mode = mode;
_transactionDetails.modeChanged = true;
if (newScaleFactor != _scaleFactor) {
_transactionDetails.needHotswap = true;
_scaleFactor = newScaleFactor;
}
_transactionDetails.needUpdatescreen = true;
return true;
}
// NOTE: This should not be executed at transaction commit
// Otherwise there is some unsolicited setGraphicsMode() call
// which should be properly removed
if (newScaleFactor != _scaleFactor) {
assert(_transactionMode != kTransactionCommit);
_scaleFactor = newScaleFactor;
hotswapGFXMode();
}
// Determine the "scaler type", i.e. essentially an index into the
// s_gfxModeSwitchTable array defined in events.cpp.
if (_mode != GFX_NORMAL) {
for (int i = 0; i < ARRAYSIZE(s_gfxModeSwitchTable); i++) {
if (s_gfxModeSwitchTable[i][1] == _mode || s_gfxModeSwitchTable[i][2] == _mode) {
_scalerType = i;
break;
}
}
}
if (!_screen)
return true;
// Blit everything to the screen
_forceFull = true;
// Even if the old and new scale factors are the same, we may have a
// different scaler for the cursor now.
blitCursor();
if (_transactionMode != kTransactionCommit)
internUpdateScreen();
// Make sure that an EVENT_SCREEN_CHANGED gets sent later
_modeChanged = true;
return true;
}
