void WINCESdlGraphicsManager::setMouseCursor(const void *buf, uint w, uint h, int hotspot_x, int hotspot_y, uint32 keycolor, bool dontScale, const Graphics::PixelFormat *format) {
undrawMouse();
if (w == 0 || h == 0)
return;
_mouseCurState.w = w;
_mouseCurState.h = h;
_mouseHotspotX = hotspot_x;
_mouseHotspotY = hotspot_y;
_mouseKeyColor = keycolor;
free(_mouseData);
_mouseData = (byte *) malloc(w * h);
memcpy(_mouseData, buf, w * h);
if (w > _mouseBackupDim || h > _mouseBackupDim) {
// mouse has been undrawn, adjust sprite backup area
free(_mouseBackupOld);
free(_mouseBackupToolbar);
uint16 tmp = (w > h) ? w : h;
_mouseBackupOld = (byte *) malloc(tmp * tmp * 2); // can hold 8bpp (playfield) or 16bpp (overlay) data
_mouseBackupToolbar = (uint16 *) malloc(tmp * tmp * 2); // 16 bpp
_mouseBackupDim = tmp;
}
}
void WINCESdlGraphicsManager::setMousePos(int x, int y) {
if (x != _mouseCurState.x || y != _mouseCurState.y) {
undrawMouse();
_mouseCurState.x = x;
_mouseCurState.y = y;
updateScreen();
}
}
void WINCESdlGraphicsManager::copyRectToScreen(const void *buf, int pitch, int x, int y, int w, int h) {
assert(_transactionMode == kTransactionNone);
assert(buf);
if (_screen == NULL)
return;
Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
const byte *src = (const byte *)buf;
/* Clip the coordinates */
if (x < 0) {
w += x;
src -= x;
x = 0;
}
if (y < 0) {
h += y;
src -= y * pitch;
y = 0;
}
if (w > _videoMode.screenWidth - x) {
w = _videoMode.screenWidth - x;
}
if (h > _videoMode.screenHeight - y) {
h = _videoMode.screenHeight - y;
}
if (w <= 0 || h <= 0)
return;
addDirtyRect(x, y, w, h);
undrawMouse();
// Try to lock the screen surface
if (SDL_LockSurface(_screen) == -1)
error("SDL_LockSurface failed: %s", SDL_GetError());
byte *dst = (byte *)_screen->pixels + y * _videoMode.screenWidth + x;
if (_videoMode.screenWidth == pitch && pitch == w) {
memcpy(dst, src, h * w);
} else {
do {
memcpy(dst, src, w);
src += pitch;
dst += _videoMode.screenWidth;
} while (--h);
}
// Unlock the screen surface
SDL_UnlockSurface(_screen);
}
void WINCESdlGraphicsManager::hideOverlay() {
assert(_transactionMode == kTransactionNone);
if (!_overlayVisible)
return;
undrawMouse();
_overlayVisible = false;
clearOverlay();
_forceFull = true;
}
void WINCESdlGraphicsManager::showOverlay() {
assert(_transactionMode == kTransactionNone);
if (_overlayVisible)
return;
undrawMouse();
_overlayVisible = true;
update_scalers();
clearOverlay();
}
bool WINCESdlGraphicsManager::showMouse(bool visible) {
if (_mouseVisible == visible)
return visible;
if (visible == false)
undrawMouse();
bool last = _mouseVisible;
_mouseVisible = visible;
_mouseNeedsRedraw = true;
return last;
}
void WINCESdlGraphicsManager::copyRectToOverlay(const void *buf, int pitch, int x, int y, int w, int h) {
assert(_transactionMode == kTransactionNone);
if (_overlayscreen == NULL)
return;
const byte *src = (const byte *)buf;
// Clip the coordinates
if (x < 0) {
w += x;
src -= x * 2;
x = 0;
}
if (y < 0) {
h += y;
src -= y * pitch;
y = 0;
}
if (w > _videoMode.overlayWidth - x) {
w = _videoMode.overlayWidth - x;
}
if (h > _videoMode.overlayHeight - y) {
h = _videoMode.overlayHeight - y;
}
if (w <= 0 || h <= 0)
return;
// Mark the modified region as dirty
addDirtyRect(x, y, w, h);
undrawMouse();
if (SDL_LockSurface(_overlayscreen) == -1)
error("SDL_LockSurface failed: %s", SDL_GetError());
byte *dst = (byte *)_overlayscreen->pixels + y * _overlayscreen->pitch + x * 2;
do {
memcpy(dst, src, w * 2);
dst += _overlayscreen->pitch;
src += pitch;
} while (--h);
SDL_UnlockSurface(_overlayscreen);
}
void WINCESdlGraphicsManager::swap_mouse_visibility() {
_forceHideMouse = !_forceHideMouse;
if (_forceHideMouse)
undrawMouse();
}
Graphics::Surface *WINCESdlGraphicsManager::lockScreen() {
// Make sure mouse pointer is not painted over the playfield at the time of locking
undrawMouse();
return SurfaceSdlGraphicsManager::lockScreen();
}
void DINGUXSdlGraphicsManager::internUpdateScreen() {
SDL_Surface *srcSurf, *origSurf;
int height, width;
ScalerProc *scalerProc;
int scale1;
#if defined(DEBUG) && ! defined(_WIN32_WCE) // definitions not available for non-DEBUG here. (needed this to compile in SYMBIAN32 & linux?)
assert(_hwscreen != NULL);
assert(_hwscreen->map->sw_data != NULL);
#endif
// If the shake position changed, fill the dirty area with blackness
if (_currentShakePos != _newShakePos) {
SDL_Rect blackrect = {0, 0, _videoMode.screenWidth * _videoMode.scaleFactor, _newShakePos * _videoMode.scaleFactor};
if (_videoMode.aspectRatioCorrection && !_overlayVisible)
blackrect.h = real2Aspect(blackrect.h - 1) + 1;
SDL_FillRect(_hwscreen, &blackrect, 0);
_currentShakePos = _newShakePos;
_forceFull = true;
}
// Check whether the palette was changed in the meantime and update the
// screen surface accordingly.
if (_screen && _paletteDirtyEnd != 0) {
SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart,
_paletteDirtyStart,
_paletteDirtyEnd - _paletteDirtyStart);
_paletteDirtyEnd = 0;
_forceFull = true;
}
#ifdef USE_OSD
// OSD visible (i.e. non-transparent)?
if (_osdMessageAlpha != SDL_ALPHA_TRANSPARENT) {
// Updated alpha value
const int diff = SDL_GetTicks() - _osdMessageFadeStartTime;
if (diff > 0) {
if (diff >= kOSDFadeOutDuration) {
// Back to full transparency
_osdMessageAlpha = SDL_ALPHA_TRANSPARENT;
} else {
// Do a linear fade out...
const int startAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
_osdMessageAlpha = startAlpha + diff * (SDL_ALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration;
}
_forceFull = true;
}
if (_osdMessageAlpha == SDL_ALPHA_TRANSPARENT) {
removeOSDMessage();
} else {
if (_osdMessageSurface && _osdSurface) {
SDL_Rect dstRect;
dstRect.x = (_osdSurface->w - _osdMessageSurface->w) / 2;
dstRect.y = (_osdSurface->h - _osdMessageSurface->h) / 2;
dstRect.w = _osdMessageSurface->w;
dstRect.h = _osdMessageSurface->h;
blitOSDMessage(dstRect);
}
}
}
#endif
if (!_overlayVisible) {
origSurf = _screen;
srcSurf = _tmpscreen;
width = _videoMode.screenWidth;
height = _videoMode.screenHeight;
scalerProc = _scalerProc;
scale1 = _videoMode.scaleFactor;
} else {
origSurf = _overlayscreen;
srcSurf = _tmpscreen2;
width = _videoMode.overlayWidth;
height = _videoMode.overlayHeight;
scalerProc = Normal1x;
scale1 = 1;
}
// Add the area covered by the mouse cursor to the list of dirty rects if
// we have to redraw the mouse.
if (_mouseNeedsRedraw)
undrawMouse();
// Force a full redraw if requested
if (_forceFull) {
_numDirtyRects = 1;
_dirtyRectList[0].x = 0;
_dirtyRectList[0].y = 0;
_dirtyRectList[0].w = width;
_dirtyRectList[0].h = height;
}
// Only draw anything if necessary
if (_numDirtyRects > 0 || _mouseNeedsRedraw) {
SDL_Rect *r;
SDL_Rect dst;
uint32 srcPitch, dstPitch;
SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
for (r = _dirtyRectList; r != lastRect; ++r) {
dst = *r;
dst.x++; // Shift rect by one since 2xSai needs to access the data around
dst.y++; // any pixel to scale it, and we want to avoid mem access crashes.
if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
error("SDL_BlitSurface failed: %s", SDL_GetError());
}
SDL_LockSurface(srcSurf);
SDL_LockSurface(_hwscreen);
srcPitch = srcSurf->pitch;
dstPitch = _hwscreen->pitch;
for (r = _dirtyRectList; r != lastRect; ++r) {
register int dst_y = r->y + _currentShakePos;
register int dst_h = 0;
register int dst_w = r->w;
register int orig_dst_y = 0;
register int dst_x = r->x;
register int src_y;
register int src_x;
if (dst_y < height) {
dst_h = r->h;
if (dst_h > height - dst_y)
dst_h = height - dst_y;
orig_dst_y = dst_y;
src_x = dst_x;
src_y = dst_y;
if (_videoMode.aspectRatioCorrection && !_overlayVisible)
dst_y = real2Aspect(dst_y);
assert(scalerProc != NULL);
if ((_videoMode.mode == GFX_HALF) && (scalerProc == DownscaleAllByHalf)) {
if (dst_x % 2 == 1) {
dst_x--;
dst_w++;
}
if (dst_y % 2 == 1) {
dst_y--;
dst_h++;
}
src_x = dst_x;
src_y = dst_y;
dst_x = dst_x / 2;
dst_y = dst_y / 2;
scalerProc((byte *)srcSurf->pixels + (src_x * 2 + 2) + (src_y + 1) * srcPitch, srcPitch,
(byte *)_hwscreen->pixels + dst_x * 2 + dst_y * dstPitch, dstPitch, dst_w, dst_h);
} else {
scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
(byte *)_hwscreen->pixels + r->x * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h);
}
}
if (_videoMode.mode == GFX_HALF && scalerProc == DownscaleAllByHalf) {
r->w = r->w / 2;
r->h = dst_h / 2;
} else {
r->w = r->w;
r->h = dst_h;
}
r->x = dst_x;
r->y = dst_y;
#ifdef USE_SCALERS
if (_videoMode.aspectRatioCorrection && orig_dst_y < height && !_overlayVisible)
r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1);
#endif
}
SDL_UnlockSurface(srcSurf);
SDL_UnlockSurface(_hwscreen);
// Readjust the dirty rect list in case we are doing a full update.
// This is necessary if shaking is active.
if (_forceFull) {
_dirtyRectList[0].y = 0;
_dirtyRectList[0].h = (_videoMode.mode == GFX_HALF) ? effectiveScreenHeight() / 2 : effectiveScreenHeight();
}
drawMouse();
#ifdef USE_OSD
if (_osdMessageAlpha != SDL_ALPHA_TRANSPARENT)
SDL_BlitSurface(_osdSurface, 0, _hwscreen, 0);
#endif
// Finally, blit all our changes to the screen
SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
}
_numDirtyRects = 0;
_forceFull = false;
_mouseNeedsRedraw = false;
}
void OSystem_SDL::internUpdateScreen() {
SDL_Surface *srcSurf, *origSurf;
int height, width;
ScalerProc *scalerProc;
int scale1;
#if defined (DEBUG) && ! defined(_WIN32_WCE) // definitions not available for non-DEBUG here. (needed this to compile in SYMBIAN32 & linux?)
assert(_hwscreen != NULL);
assert(_hwscreen->map->sw_data != NULL);
#endif
// If the shake position changed, fill the dirty area with blackness
if (_currentShakePos != _newShakePos) {
SDL_Rect blackrect = {0, 0, _screenWidth * _scaleFactor, _newShakePos * _scaleFactor};
if (_adjustAspectRatio && !_overlayVisible)
blackrect.h = real2Aspect(blackrect.h - 1) + 1;
SDL_FillRect(_hwscreen, &blackrect, 0);
_currentShakePos = _newShakePos;
_forceFull = true;
}
// Check whether the palette was changed in the meantime and update the
// screen surface accordingly.
if (_paletteDirtyEnd != 0) {
SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart,
_paletteDirtyStart,
_paletteDirtyEnd - _paletteDirtyStart);
_paletteDirtyEnd = 0;
_forceFull = true;
}
#ifdef USE_OSD
// OSD visible (i.e. non-transparent)?
if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
// Updated alpha value
const int diff = SDL_GetTicks() - _osdFadeStartTime;
if (diff > 0) {
if (diff >= kOSDFadeOutDuration) {
// Back to full transparency
_osdAlpha = SDL_ALPHA_TRANSPARENT;
} else {
// Do a linear fade out...
const int startAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
_osdAlpha = startAlpha + diff * (SDL_ALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration;
}
SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha);
_forceFull = true;
}
}
#endif
if (!_overlayVisible) {
origSurf = _screen;
srcSurf = _tmpscreen;
width = _screenWidth;
height = _screenHeight;
scalerProc = _scalerProc;
scale1 = _scaleFactor;
} else {
origSurf = _overlayscreen;
srcSurf = _tmpscreen2;
width = _overlayWidth;
height = _overlayHeight;
scalerProc = Normal1x;
scale1 = 1;
}
// Force a full redraw if requested
if (_forceFull) {
_numDirtyRects = 1;
_dirtyRectList[0].x = 0;
_dirtyRectList[0].y = 0;
_dirtyRectList[0].w = width;
_dirtyRectList[0].h = height;
} else
undrawMouse();
// Only draw anything if necessary
if (_numDirtyRects > 0) {
SDL_Rect *r;
SDL_Rect dst;
uint32 srcPitch, dstPitch;
SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
if (scalerProc == Normal1x && !_adjustAspectRatio && 0) {
for (r = _dirtyRectList; r != lastRect; ++r) {
dst = *r;
dst.y += _currentShakePos;
if (SDL_BlitSurface(origSurf, r, _hwscreen, &dst) != 0)
error("SDL_BlitSurface failed: %s", SDL_GetError());
}
} else {
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.
if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
error("SDL_BlitSurface failed: %s", SDL_GetError());
}
SDL_LockSurface(srcSurf);
SDL_LockSurface(_hwscreen);
srcPitch = srcSurf->pitch;
dstPitch = _hwscreen->pitch;
for (r = _dirtyRectList; r != lastRect; ++r) {
register int dst_y = r->y + _currentShakePos;
register int dst_h = 0;
register int orig_dst_y = 0;
register int rx1 = r->x * scale1;
if (dst_y < height) {
dst_h = r->h;
if (dst_h > height - dst_y)
dst_h = height - dst_y;
orig_dst_y = dst_y;
dst_y = dst_y * scale1;
if (_adjustAspectRatio && !_overlayVisible)
dst_y = real2Aspect(dst_y);
assert(scalerProc != NULL);
scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
(byte *)_hwscreen->pixels + rx1 * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h);
}
r->x = rx1;
r->y = dst_y;
r->w = r->w * scale1;
r->h = dst_h * scale1;
#ifndef DISABLE_SCALERS
if (_adjustAspectRatio && orig_dst_y < height && !_overlayVisible)
r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1);
#endif
}
SDL_UnlockSurface(srcSurf);
SDL_UnlockSurface(_hwscreen);
}
// Readjust the dirty rect list in case we are doing a full update.
// This is necessary if shaking is active.
if (_forceFull) {
_dirtyRectList[0].y = 0;
_dirtyRectList[0].h = effectiveScreenHeight();
}
drawMouse();
#ifdef USE_OSD
if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
SDL_BlitSurface(_osdSurface, 0, _hwscreen, 0);
}
#endif
// Finally, blit all our changes to the screen
SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
} else {
drawMouse();
if (_numDirtyRects)
SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
}
_numDirtyRects = 0;
_forceFull = false;
}
void GPHGraphicsManager::internUpdateScreen() {
SDL_Surface *srcSurf, *origSurf;
int height, width;
ScalerProc *scalerProc;
int scale1;
#if defined(DEBUG)
assert(_hwscreen != NULL);
assert(_hwscreen->map->sw_data != NULL);
#endif
// If the shake position changed, fill the dirty area with blackness
if (_currentShakePos != _newShakePos ||
(_mouseNeedsRedraw && _mouseBackup.y <= _currentShakePos)) {
SDL_Rect blackrect = {0, 0, _videoMode.screenWidth *_videoMode.scaleFactor, _newShakePos *_videoMode.scaleFactor};
if (_videoMode.aspectRatioCorrection && !_overlayVisible)
blackrect.h = real2Aspect(blackrect.h - 1) + 1;
SDL_FillRect(_hwscreen, &blackrect, 0);
_currentShakePos = _newShakePos;
_forceFull = true;
}
// Check whether the palette was changed in the meantime and update the
// screen surface accordingly.
if (_screen && _paletteDirtyEnd != 0) {
SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart,
_paletteDirtyStart,
_paletteDirtyEnd - _paletteDirtyStart);
_paletteDirtyEnd = 0;
_forceFull = true;
}
if (!_overlayVisible) {
origSurf = _screen;
srcSurf = _tmpscreen;
width = _videoMode.screenWidth;
height = _videoMode.screenHeight;
scalerProc = _scalerProc;
scale1 = _videoMode.scaleFactor;
} else {
origSurf = _overlayscreen;
srcSurf = _tmpscreen2;
width = _videoMode.overlayWidth;
height = _videoMode.overlayHeight;
scalerProc = Normal1x;
scale1 = 1;
}
// Add the area covered by the mouse cursor to the list of dirty rects if
// we have to redraw the mouse.
if (_mouseNeedsRedraw)
undrawMouse();
#ifdef USE_OSD
updateOSD();
#endif
// Force a full redraw if requested
if (_forceFull) {
_numDirtyRects = 1;
_dirtyRectList[0].x = 0;
_dirtyRectList[0].y = 0;
_dirtyRectList[0].w = width;
_dirtyRectList[0].h = height;
// HACK: Make sure the full hardware screen is wiped clean.
SDL_FillRect(_hwscreen, NULL, 0);
}
// Only draw anything if necessary
if (_numDirtyRects > 0 || _mouseNeedsRedraw) {
SDL_Rect *r;
SDL_Rect dst;
uint32 srcPitch, dstPitch;
SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
for (r = _dirtyRectList; r != lastRect; ++r) {
dst = *r;
dst.x++; // Shift rect by one since 2xSai needs to access the data around
dst.y++; // any pixel to scale it, and we want to avoid mem access crashes.
if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
error("SDL_BlitSurface failed: %s", SDL_GetError());
}
SDL_LockSurface(srcSurf);
SDL_LockSurface(_hwscreen);
srcPitch = srcSurf->pitch;
dstPitch = _hwscreen->pitch;
for (r = _dirtyRectList; r != lastRect; ++r) {
register int dst_y = r->y + _currentShakePos;
register int dst_h = 0;
register int dst_w = r->w;
register int orig_dst_y = 0;
register int dst_x = r->x;
register int src_y;
register int src_x;
if (dst_y < height) {
dst_h = r->h;
if (dst_h > height - dst_y)
dst_h = height - dst_y;
orig_dst_y = dst_y;
src_x = dst_x;
src_y = dst_y;
if (_videoMode.aspectRatioCorrection && !_overlayVisible)
dst_y = real2Aspect(dst_y);
assert(scalerProc != NULL);
if ((_videoMode.mode == GFX_HALF) && (scalerProc == DownscaleAllByHalf)) {
if (dst_x % 2 == 1) {
dst_x--;
dst_w++;
}
if (dst_y % 2 == 1) {
dst_y--;
dst_h++;
}
src_x = dst_x;
src_y = dst_y;
dst_x = dst_x / 2;
dst_y = dst_y / 2;
scalerProc((byte *)srcSurf->pixels + (src_x * 2 + 2) + (src_y + 1) * srcPitch, srcPitch,
(byte *)_hwscreen->pixels + dst_x * 2 + dst_y * dstPitch, dstPitch, dst_w, dst_h);
} else {
scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
(byte *)_hwscreen->pixels + r->x * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h);
}
}
if (_videoMode.mode == GFX_HALF && scalerProc == DownscaleAllByHalf) {
r->w = r->w / 2;
r->h = dst_h / 2;
} else {
r->w = r->w;
r->h = dst_h;
}
r->x = dst_x;
r->y = dst_y;
#ifdef USE_SCALERS
if (_videoMode.aspectRatioCorrection && orig_dst_y < height && !_overlayVisible)
r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1);
#endif
}
SDL_UnlockSurface(srcSurf);
SDL_UnlockSurface(_hwscreen);
// Readjust the dirty rect list in case we are doing a full update.
// This is necessary if shaking is active.
if (_forceFull) {
_dirtyRectList[0].y = 0;
_dirtyRectList[0].h = (_videoMode.mode == GFX_HALF) ? effectiveScreenHeight() / 2 : effectiveScreenHeight();
}
drawMouse();
#ifdef USE_OSD
drawOSD();
#endif
// Finally, blit all our changes to the screen
SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
}
_numDirtyRects = 0;
_forceFull = false;
_mouseNeedsRedraw = false;
}
