void VisualExplodingImage::ExplosionUnit::setColor(uint32 color, const Graphics::PixelFormat &format) {
_mainColor = color;
byte a, r, g, b;
format.colorToARGB(color, a, r, g, b);
r >>= 1;
g >>= 1;
b >>= 1;
_darkColor = format.ARGBToColor(a, r, g, b);
}
bool createScreenShot(Graphics::Surface &surf) {
Graphics::PixelFormat screenFormat = g_system->getScreenFormat();
//convert surface to 2 bytes pixel format to avoid problems with palette saving and loading
if ((screenFormat.bytesPerPixel == 1) || (screenFormat.bytesPerPixel == 2)) {
return grabScreen565(&surf);
} else {
Graphics::Surface *screen = g_system->lockScreen();
if (!screen) {
return false;
}
surf.create(screen->w, screen->h, Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0));
for (uint y = 0; y < screen->h; ++y) {
for (uint x = 0; x < screen->w; ++x) {
byte r = 0, g = 0, b = 0, a = 0;
uint32 col = READ_UINT32(screen->getBasePtr(x, y));
screenFormat.colorToARGB(col, a, r, g, b);
*((uint32 *)surf.getBasePtr(x, y)) = Graphics::ARGBToColor<Graphics::ColorMasks<8888> >(a, r, g, b);
}
}
g_system->unlockScreen();
return true;
}
}
bool UIWindow::display(int offsetX, int offsetY) {
// go exclusive
if (_mode == WINDOW_EXCLUSIVE || _mode == WINDOW_SYSTEM_EXCLUSIVE) {
if (!_shieldWindow) {
_shieldWindow = new UIWindow(_gameRef);
}
if (_shieldWindow) {
_shieldWindow->_posX = _shieldWindow->_posY = 0;
_shieldWindow->_width = _gameRef->_renderer->getWidth();
_shieldWindow->_height = _gameRef->_renderer->getHeight();
_shieldWindow->display();
}
} else if (_isMenu) {
if (!_shieldButton) {
_shieldButton = new UIButton(_gameRef);
_shieldButton->setName("close");
_shieldButton->setListener(this, _shieldButton, 0);
_shieldButton->_parent = this;
}
if (_shieldButton) {
_shieldButton->_posX = _shieldButton->_posY = 0;
_shieldButton->setWidth(_gameRef->_renderer->getWidth());
_shieldButton->setHeight(_gameRef->_renderer->getHeight());
_shieldButton->display();
}
}
if (!_visible) {
return STATUS_OK;
}
if (_fadeBackground) {
Graphics::PixelFormat format = _gameRef->_renderer->getPixelFormat();
byte fadeR, fadeG, fadeB, fadeA;
// First convert from the internal format to the screen-format
uint32 fadeColor = format.ARGBToColor(RGBCOLGetA(_fadeColor), RGBCOLGetR(_fadeColor), RGBCOLGetG(_fadeColor), RGBCOLGetB(_fadeColor));
// Then get components
format.colorToARGB(fadeColor, fadeA, fadeR, fadeG, fadeB);
_gameRef->_renderer->fadeToColor(fadeR, fadeG, fadeB, fadeA);
}
if (_dragging) {
_posX += (_gameRef->_mousePos.x - _dragFrom.x);
_posY += (_gameRef->_mousePos.y - _dragFrom.y);
_dragFrom.x = _gameRef->_mousePos.x;
_dragFrom.y = _gameRef->_mousePos.y;
}
if (!_focusedWidget || (!_focusedWidget->canFocus() || _focusedWidget->isDisabled() || !_focusedWidget->isVisible())) {
moveFocus();
}
bool popViewport = false;
if (_clipContents) {
if (!_viewport) {
_viewport = new BaseViewport(_gameRef);
}
if (_viewport) {
_viewport->setRect(_posX + offsetX, _posY + offsetY, _posX + _width + offsetX, _posY + _height + offsetY);
_gameRef->pushViewport(_viewport);
popViewport = true;
}
}
UITiledImage *back = _back;
BaseSprite *image = _image;
BaseFont *font = _font;
if (!isFocused()) {
if (_backInactive) {
back = _backInactive;
}
if (_imageInactive) {
image = _imageInactive;
}
if (_fontInactive) {
font = _fontInactive;
}
}
if (_alphaColor != 0) {
_gameRef->_renderer->_forceAlphaColor = _alphaColor;
}
if (back) {
back->display(_posX + offsetX, _posY + offsetY, _width, _height);
}
if (image) {
image->draw(_posX + offsetX, _posY + offsetY, _transparent ? nullptr : this);
}
if (!BasePlatform::isRectEmpty(&_titleRect) && font && _text) {
font->drawText((byte *)_text, _posX + offsetX + _titleRect.left, _posY + offsetY + _titleRect.top, _titleRect.right - _titleRect.left, _titleAlign, _titleRect.bottom - _titleRect.top);
}
if (!_transparent && !image) {
_gameRef->_renderer->addRectToList(new BaseActiveRect(_gameRef, this, nullptr, _posX + offsetX, _posY + offsetY, _width, _height, 100, 100, false));
}
for (uint32 i = 0; i < _widgets.size(); i++) {
_widgets[i]->display(_posX + offsetX, _posY + offsetY);
}
if (_alphaColor != 0) {
_gameRef->_renderer->_forceAlphaColor = 0;
}
if (popViewport) {
_gameRef->popViewport();
}
return STATUS_OK;
}
// Function to blit a rect from one color format to another
bool crossBlit(byte *dst, const byte *src, int dstpitch, int srcpitch,
int w, int h, const Graphics::PixelFormat &dstFmt, const Graphics::PixelFormat &srcFmt) {
// Error out if conversion is impossible
if ((srcFmt.bytesPerPixel == 1) || (dstFmt.bytesPerPixel == 1)
|| (!srcFmt.bytesPerPixel) || (!dstFmt.bytesPerPixel)
|| (srcFmt.bytesPerPixel > dstFmt.bytesPerPixel))
return false;
// Don't perform unnecessary conversion
if (srcFmt == dstFmt) {
if (dst == src)
return true;
if (dstpitch == srcpitch && ((w * dstFmt.bytesPerPixel) == dstpitch)) {
memcpy(dst,src,dstpitch * h);
return true;
} else {
for (int i = 0; i < h; i++) {
memcpy(dst,src,w * dstFmt.bytesPerPixel);
dst += dstpitch;
src += srcpitch;
}
return true;
}
}
// Faster, but larger, to provide optimized handling for each case.
int srcDelta, dstDelta;
srcDelta = (srcpitch - w * srcFmt.bytesPerPixel);
dstDelta = (dstpitch - w * dstFmt.bytesPerPixel);
// TODO: optimized cases for dstDelta of 0
uint8 r, g, b, a;
if (dstFmt.bytesPerPixel == 2) {
uint16 color;
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++, src += 2, dst += 2) {
color = *(const uint16 *)src;
srcFmt.colorToARGB(color, a, r, g, b);
color = dstFmt.ARGBToColor(a, r, g, b);
*(uint16 *)dst = color;
}
src += srcDelta;
dst += dstDelta;
}
} else if (dstFmt.bytesPerPixel == 3) {
uint32 color;
uint8 *col = (uint8 *) &color;
#ifdef SCUMM_BIG_ENDIAN
col++;
#endif
if (srcFmt.bytesPerPixel == 2) {
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++, src += 2, dst += 3) {
color = *(const uint16 *)src;
srcFmt.colorToARGB(color, a, r, g, b);
color = dstFmt.ARGBToColor(a, r, g, b);
memcpy(dst, col, 3);
}
src += srcDelta;
dst += dstDelta;
}
} else {
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++, src += 3, dst += 3) {
memcpy(col, src, 3);
srcFmt.colorToARGB(color, a, r, g, b);
color = dstFmt.ARGBToColor(a, r, g, b);
memcpy(dst, col, 3);
}
src += srcDelta;
dst += dstDelta;
}
}
} else if (dstFmt.bytesPerPixel == 4) {
uint32 color;
if (srcFmt.bytesPerPixel == 2) {
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++, src += 2, dst += 4) {
color = *(const uint16 *)src;
srcFmt.colorToARGB(color, a, r, g, b);
color = dstFmt.ARGBToColor(a, r, g, b);
*(uint32 *)dst = color;
}
src += srcDelta;
dst += dstDelta;
}
} else if (srcFmt.bytesPerPixel == 3) {
uint8 *col = (uint8 *)&color;
#ifdef SCUMM_BIG_ENDIAN
col++;
#endif
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++, src += 2, dst += 4) {
memcpy(col, src, 3);
srcFmt.colorToARGB(color, a, r, g, b);
color = dstFmt.ARGBToColor(a, r, g, b);
*(uint32 *)dst = color;
}
src += srcDelta;
dst += dstDelta;
}
} else {
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++, src += 4, dst += 4) {
color = *(const uint32 *)src;
srcFmt.colorToARGB(color, a, r, g, b);
color = dstFmt.ARGBToColor(a, r, g, b);
*(uint32 *)dst = color;
}
src += srcDelta;
dst += dstDelta;
}
}
} else {
return false;
}
return true;
}