QuitDialogInputState_BR(Parallaction_br *vm, MenuInputHelper *helper) : MenuInputState("quitdialog", helper), _vm(vm) {
_font = _vm->_dialogueFont;
const char *question = "Do you really want to quit ?";
const char *option = "Yes No";
int questionW = _font->getStringWidth(question);
int optionW = _font->getStringWidth(option);
int w = MAX(questionW, optionW) + 30;
_x = (640 - w) / 2;
_y = 90;
Graphics::Surface *surf = new Graphics::Surface;
surf->create(w, 110, Graphics::PixelFormat::createFormatCLUT8());
surf->fillRect(Common::Rect(0, 0, w, 110), 12);
surf->fillRect(Common::Rect(10, 10, w-10, 100), 15);
_font->setColor(0);
int x = (w - questionW)/2;
int y = 13;
_font->drawString((byte *)surf->getBasePtr(x, y), surf->pitch, question);
x = (w - optionW)/2;
y = 13 + _font->height()*2;
_font->drawString((byte *)surf->getBasePtr(x,y), surf->pitch, option);
_obj = new GfxObj(kGfxObjTypeMenu, new SurfaceToFrames(surf), "quitdialog");
assert(_obj);
}
void KIASectionCrimes::draw(Graphics::Surface &surface) {
const char *text = nullptr;
if (_suspectPhotoShapeId != -1) {
_suspectPhotoShape->draw(surface, 201 - _suspectPhotoShape->getWidth() / 2, 223 - _suspectPhotoShape->getHeight() / 2);
}
if (_suspectPhotoShapeId == 14 || _suspectPhotoShapeId == 13) {
text = _vm->_textKIA->getText(49);
_vm->_mainFont->drawColor(text, surface, 201 - _vm->_mainFont->getTextWidth(text) / 2, 218, 0x7FFF);
}
surface.fillRect(Common::Rect(120, 134, 250, 145), 0);
surface.hLine(120, 133, 250, 0x18A5);
surface.hLine(120, 146, 250, 0x2D4C);
surface.vLine(119, 134, 145, 0x18A5);
surface.vLine(251, 134, 145, 0x2D4C);
surface.hLine(251, 146, 251, 0x2509);
if (_crimeSelected == -1) {
text = _vm->_textKIA->getText(49);
} else {
text = _vm->_textCrimes->getText(_crimeSelected);
}
_vm->_mainFont->drawColor(text, surface, 185 - _vm->_mainFont->getTextWidth(text) / 2, 136, 0x46BF);
surface.fillRect(Common::Rect(136, 304, 266, 315), 0);
surface.hLine(136, 303, 266, 0x18A5);
surface.hLine(136, 316, 266, 0x2D4C);
surface.vLine(135, 304, 315, 0x18A5);
surface.vLine(267, 304, 315, 0x2D4C);
surface.hLine(267, 316, 267, 0x2509);
char generatedText[64];
if (_suspectSelected == -1) {
text = _vm->_textKIA->getText(22);
} else {
const char *suspectName = _vm->_suspectsDatabase->get(_suspectSelected)->getName();
if (_suspectsWithIdentity[_suspectSelected]) {
text = suspectName;
} else if (_vm->_suspectsDatabase->get(_suspectSelected)->getSex()) {
sprintf(generatedText, "%s %s", _vm->_textKIA->getText(20), KIASectionSuspects::scrambleSuspectsName(suspectName));
text = generatedText;
} else {
sprintf(generatedText, "%s %s", _vm->_textKIA->getText(21), KIASectionSuspects::scrambleSuspectsName(suspectName));
text = generatedText;
}
}
_vm->_mainFont->drawColor(text, surface, 201 - _vm->_mainFont->getTextWidth(text) / 2, 306, 0x46BF);
_uiContainer->draw(surface);
_buttons->draw(surface);
_buttons->drawTooltip(surface, _mouseX, _mouseY);
}
Common::Rect EventTests::drawFinishZone() {
Graphics::Surface *screen = g_system->lockScreen();
const Graphics::Font &font(*FontMan.getFontByUsage(Graphics::FontManager::kBigGUIFont));
int width = 35;
int height = 20;
int right = g_system->getWidth();
Common::Rect rect(0, 0, right, height);
Common::Rect rect2(0, 0, right - width, height);
screen->fillRect(rect, kColorSpecial);
screen->fillRect(rect2, kColorBlack);
g_system->unlockScreen();
font.drawString(screen, "Close", rect.left, rect.top, screen->w, kColorBlack, Graphics::kTextAlignRight);
g_system->updateScreen();
return Common::Rect(right - width, 0, right, height);
}
void VisualText::createTexture() {
// Get the font and required metrics
const Graphics::Font *font = StarkFontProvider->getScaledFont(_fontType, _fontCustomIndex);
uint scaledLineHeight = StarkFontProvider->getScaledFontHeight(_fontType, _fontCustomIndex);
uint originalLineHeight = StarkFontProvider->getOriginalFontHeight(_fontType, _fontCustomIndex);
uint maxScaledLineWidth = StarkFontProvider->scaleWidthOriginalToCurrent(_originalRect.width());
// Word wrap the text and compute the scaled and original resolution bounding boxes
Common::Rect scaledRect;
Common::Array<Common::String> lines;
scaledRect.right = scaledRect.left + font->wordWrapText(_text, maxScaledLineWidth, lines);
scaledRect.bottom = scaledRect.top + scaledLineHeight * lines.size();
_originalRect.bottom = _originalRect.top + originalLineHeight * lines.size();
// Create a surface to render to
Graphics::Surface surface;
surface.create(scaledRect.width(), scaledRect.height(), _gfx->getScreenFormat());
surface.fillRect(scaledRect, _backgroundColor);
// Render the lines to the surface
for (uint i = 0; i < lines.size(); i++) {
font->drawString(&surface, lines[i], 0, scaledLineHeight * i, scaledRect.width(), _color);
}
// Create a texture from the surface
_texture = _gfx->createTexture(&surface);
surface.free();
}
static void drawMessage(int offset, const Common::String &text) {
const Graphics::Font &font(*FontMan.getFontByUsage(Graphics::FontManager::kGUIFont));
Graphics::Surface *screen = g_system->lockScreen();
assert(screen);
assert(screen->pixels);
Graphics::PixelFormat screenFormat = g_system->getScreenFormat();
uint16 h = font.getFontHeight();
uint16 y = g_system->getHeight() / 2 - h / 2 + offset * (h + 1);
uint32 col;
if (screenFormat.bytesPerPixel > 1)
col = screenFormat.RGBToColor(0, 0, 0);
else
col = 0;
Common::Rect r(0, y, screen->w, y + h);
screen->fillRect(r, col);
if (screenFormat.bytesPerPixel > 1)
col = screenFormat.RGBToColor(0, 171, 0);
else
col = 1;
font.drawString(screen, text, 0, y, screen->w, col, Graphics::kTextAlignCenter);
g_system->unlockScreen();
g_system->updateScreen();
}
void Script::o_printstring() {
char stringstorage[15];
uint8 counter = 0;
debugScript(1, true, "PRINTSTRING");
memset(stringstorage, 0, 15);
do {
char newchar = readScriptChar(true, true, true) + 0x30;
if (newchar < 0x30 || newchar > 0x39) { // If character is invalid, chuck a space in
if (newchar < 0x41 || newchar > 0x7A) {
newchar = 0x20;
}
}
stringstorage[counter] = newchar;
counter++;
} while (!(getCodeByte(_currentInstruction - 1) & 0x80));
stringstorage[counter] = 0;
Common::Rect topbar(640, 80);
Graphics::Surface *gamescreen = _vm->_system->lockScreen();
// Clear the top bar
gamescreen->fillRect(topbar, 0);
// Draw the string
printString(gamescreen, stringstorage);
_vm->_system->unlockScreen();
}
void BaseRenderOSystem::fadeToColor(byte r, byte g, byte b, byte a, Common::Rect *rect) {
Common::Rect fillRect;
if (rect) {
fillRect.left = rect->left;
fillRect.top = rect->top;
fillRect.setWidth(rect->width());
fillRect.setHeight(rect->height());
} else {
Rect32 rc;
_gameRef->getCurrentViewportRect(&rc);
fillRect.left = (int16)rc.left;
fillRect.top = (int16)rc.top;
fillRect.setWidth((int16)(rc.right - rc.left));
fillRect.setHeight((int16)(rc.bottom - rc.top));
}
modTargetRect(&fillRect);
//TODO: This is only here until I'm sure about the final pixelformat
uint32 col = _renderSurface->format.ARGBToColor(a, r, g, b);
Graphics::Surface surf;
surf.create((uint16)fillRect.width(), (uint16)fillRect.height(), _renderSurface->format);
Common::Rect sizeRect(fillRect);
sizeRect.translate(-fillRect.top, -fillRect.left);
surf.fillRect(fillRect, col);
TransformStruct temp = TransformStruct();
temp._alphaDisable = false;
drawSurface(nullptr, &surf, &sizeRect, &fillRect, temp);
surf.free();
//SDL_SetRenderDrawColor(_renderer, r, g, b, a);
//SDL_SetRenderDrawBlendMode(_renderer, SDL_BLENDMODE_BLEND);
//SDL_RenderFillRect(_renderer, &fillRect);
}
Common::Rect Testsuite::writeOnScreen(const Common::String &textToDisplay, const Common::Point &pt, bool flag) {
const Graphics::Font &font(*FontMan.getFontByUsage(Graphics::FontManager::kConsoleFont));
uint fillColor = kColorBlack;
uint textColor = kColorWhite;
Graphics::Surface *screen = g_system->lockScreen();
int height = font.getFontHeight();
int width = screen->w;
Common::Rect rect(pt.x, pt.y, pt.x + width, pt.y + height);
if (flag) {
Graphics::PixelFormat pf = g_system->getScreenFormat();
fillColor = pf.RGBToColor(0, 0, 0);
textColor = pf.RGBToColor(255, 255, 255);
}
screen->fillRect(rect, fillColor);
font.drawString(screen, textToDisplay, rect.left, rect.top, screen->w, textColor, Graphics::kTextAlignCenter);
g_system->unlockScreen();
g_system->updateScreen();
return rect;
}
void GfxTransitions::copyRectToScreen(const Common::Rect rect, bool blackoutFlag) {
if (!blackoutFlag) {
_screen->copyRectToScreen(rect);
} else {
Graphics::Surface *surface = g_system->lockScreen();
if (!_screen->getUpscaledHires()) {
surface->fillRect(rect, 0);
} else {
Common::Rect upscaledRect = rect;
_screen->adjustToUpscaledCoordinates(upscaledRect.top, upscaledRect.left);
_screen->adjustToUpscaledCoordinates(upscaledRect.bottom, upscaledRect.right);
surface->fillRect(upscaledRect, 0);
}
g_system->unlockScreen();
}
}
void VisualText::createTexture() {
Common::CodePage codePage = StarkSettings->getTextCodePage();
Common::U32String unicodeText = Common::convertToU32String(_text.c_str(), codePage);
// Get the font and required metrics
const Graphics::Font *font = StarkFontProvider->getScaledFont(_fontType, _fontCustomIndex);
uint scaledLineHeight = StarkFontProvider->getScaledFontHeight(_fontType, _fontCustomIndex);
uint originalLineHeight = StarkFontProvider->getOriginalFontHeight(_fontType, _fontCustomIndex);
uint maxScaledLineWidth = StarkGfx->scaleWidthOriginalToCurrent(_targetWidth);
// Word wrap the text
Common::Array<Common::U32String> lines;
font->wordWrapText(unicodeText, maxScaledLineWidth, lines);
// Use the actual font bounding box to prevent text from being cut off
Common::Rect scaledRect;
if (!lines.empty()) {
scaledRect = font->getBoundingBox(lines[0]);
for (uint i = 1; i < lines.size(); i++) {
scaledRect.extend(font->getBoundingBox(lines[i], 0, scaledLineHeight * i));
}
}
// Make sure lines have approximately consistent height regardless of the characters they use
scaledRect.bottom = MAX<int16>(scaledRect.bottom, scaledLineHeight * lines.size());
if (!isBlank()) {
_originalRect.right = StarkGfx->scaleWidthCurrentToOriginal(scaledRect.right);
_originalRect.bottom = originalLineHeight * lines.size();
} else {
// For Empty text, preserve the original width and height for being used as clicking area
_originalRect.right = _targetWidth;
_originalRect.bottom = _targetHeight;
}
// Create a surface to render to
Graphics::Surface surface;
surface.create(scaledRect.right, scaledRect.bottom, Gfx::Driver::getRGBAPixelFormat());
uint32 color = surface.format.ARGBToColor(
_color.a, _color.r, _color.g, _color.b
);
uint32 bgColor = surface.format.ARGBToColor(
_backgroundColor.a, _backgroundColor.r, _backgroundColor.g, _backgroundColor.b
);
surface.fillRect(Common::Rect(surface.w, surface.h), bgColor);
// Render the lines to the surface
for (uint i = 0; i < lines.size(); i++) {
font->drawString(&surface, lines[i], 0, scaledLineHeight * i, surface.w, color, _align);
}
// Create a texture from the surface
_texture = _gfx->createTexture(&surface);
_texture->setSamplingFilter(Gfx::Texture::kNearest);
surface.free();
}
void EnergyMonitor::draw(const Common::Rect &r) {
Common::Rect r2 = r.findIntersectingRect(_levelRect);
if (!r2.isEmpty()) {
Graphics::Surface *screen = ((PegasusEngine *)g_engine)->_gfx->getWorkArea();
screen->fillRect(r2, _barColor);
}
}
void Testsuite::clearScreen(const Common::Rect &rect) {
Graphics::Surface *screen = g_system->lockScreen();
screen->fillRect(rect, kColorBlack);
g_system->unlockScreen();
g_system->updateScreen();
}
void Script::o_hotspot_slot() {
uint16 slot = readScript8bits();
uint16 left = readScript16bits();
uint16 top = readScript16bits();
uint16 right = readScript16bits();
uint16 bottom = readScript16bits();
uint16 address = readScript16bits();
uint16 cursor = readScript8bits();
debugScript(1, true, "HOTSPOT-SLOT %d (%d,%d,%d,%d) @0x%04X cursor=%d (TODO)", slot, left, top, right, bottom, address, cursor);
Common::Rect rect(left, top, right, bottom);
if (hotspot(rect, address, cursor)) {
if (_hotspotSlot == slot) {
return;
}
Common::Rect topbar(640, 80);
Graphics::Surface *gamescreen = _vm->_system->lockScreen();
// Clear the top bar
gamescreen->fillRect(topbar, 0);
printString(gamescreen, _saveNames[slot].c_str());
_vm->_system->unlockScreen();
// Save the currently highlighted slot
_hotspotSlot = slot;
} else {
if (_hotspotSlot == slot) {
Common::Rect topbar(640, 80);
Graphics::Surface *gamescreen;
gamescreen = _vm->_system->lockScreen();
gamescreen->fillRect(topbar, 0);
_vm->_system->unlockScreen();
// Removing the slot highlight
_hotspotSlot = (uint16)-1;
}
}
}
void SoundLevel::draw(const Common::Rect &r) {
Common::Rect levelRect(_bounds.right + (8 * (_soundLevel - 12)), _bounds.top, _bounds.right, _bounds.bottom);
levelRect = r.findIntersectingRect(levelRect);
if (!levelRect.isEmpty()) {
Graphics::Surface *screen = ((PegasusEngine *)g_engine)->_gfx->getWorkArea();
screen->fillRect(levelRect, g_system->getScreenFormat().RGBToColor(0, 0, 0));
}
}
void OpenGLGraphicsManager::displayMessageOnOSD(const char *msg) {
#ifdef USE_OSD
// HACK: Actually no client code should use graphics functions from
// another thread. But the MT-32 emulator still does, thus we need to
// make sure this doesn't happen while a updateScreen call is done.
Common::StackLock lock(_osdMutex);
// Slip up the lines.
Common::Array<Common::String> osdLines;
Common::StringTokenizer tokenizer(msg, "\n");
while (!tokenizer.empty()) {
osdLines.push_back(tokenizer.nextToken());
}
// Do the actual drawing like the SDL backend.
const Graphics::Font *font = getFontOSD();
Graphics::Surface *dst = _osd->getSurface();
_osd->fill(0);
_osd->flagDirty();
// Determine a rect which would contain the message string (clipped to the
// screen dimensions).
const int vOffset = 6;
const int lineSpacing = 1;
const int lineHeight = font->getFontHeight() + 2 * lineSpacing;
int width = 0;
int height = lineHeight * osdLines.size() + 2 * vOffset;
for (uint i = 0; i < osdLines.size(); i++) {
width = MAX(width, font->getStringWidth(osdLines[i]) + 14);
}
// Clip the rect
width = MIN<int>(width, dst->w);
height = MIN<int>(height, dst->h);
int dstX = (dst->w - width) / 2;
int dstY = (dst->h - height) / 2;
// Draw a dark gray rect.
const uint32 color = dst->format.RGBToColor(40, 40, 40);
dst->fillRect(Common::Rect(dstX, dstY, dstX + width, dstY + height), color);
// Render the message, centered, and in white
const uint32 white = dst->format.RGBToColor(255, 255, 255);
for (uint i = 0; i < osdLines.size(); ++i) {
font->drawString(dst, osdLines[i],
dstX, dstY + i * lineHeight + vOffset + lineSpacing, width,
white, Graphics::kTextAlignCenter);
}
// Init the OSD display parameters.
_osdAlpha = kOSDInitialAlpha;
_osdFadeStartTime = g_system->getMillis() + kOSDFadeOutDelay;
#endif
}
void splashScreen() {
Common::MemoryReadStream stream(logo_data, ARRAYSIZE(logo_data));
Image::BitmapDecoder bitmap;
if (!bitmap.loadStream(stream)) {
warning("Error loading logo file");
return;
}
g_system->showOverlay();
// Fill with blue - ResidualVM theme
Graphics::Surface screen;
screen.create(g_system->getOverlayWidth(), g_system->getOverlayHeight(), g_system->getOverlayFormat());
screen.fillRect(Common::Rect(screen.w, screen.h), screen.format.ARGBToColor(0xff, 0x1e, 0x6f, 0x95)); // ResidualVM theme
// Load logo
Graphics::Surface *logo = bitmap.getSurface()->convertTo(g_system->getOverlayFormat(), bitmap.getPalette());
int lx = MAX((g_system->getOverlayWidth() - logo->w) / 2, 0);
int ly = MAX((g_system->getOverlayHeight() - logo->h) / 2, 0);
// Print version information
const Graphics::Font *font = FontMan.getFontByUsage(Graphics::FontManager::kConsoleFont);
int w = font->getStringWidth(gScummVMVersionDate);
int x = g_system->getOverlayWidth() - w - 5; // lx + logo->w - w + 5;
int y = g_system->getOverlayHeight() - font->getFontHeight() - 5; //ly + logo->h + 5;
font->drawString(&screen, gScummVMVersionDate, x, y, w, screen.format.ARGBToColor(0xff, 0, 0, 0));
g_system->copyRectToOverlay(screen.getPixels(), screen.pitch, 0, 0, screen.w, screen.h);
screen.free();
// Draw logo
int lw = MIN<uint16>(logo->w, g_system->getOverlayWidth() - lx);
int lh = MIN<uint16>(logo->h, g_system->getOverlayHeight() - ly);
g_system->copyRectToOverlay(logo->getPixels(), logo->pitch, lx, ly, lw, lh);
logo->free();
delete logo;
g_system->updateScreen();
// Delay 0.6 secs
uint time0 = g_system->getMillis();
Common::Event event;
while (time0 + 600 > g_system->getMillis()) {
(void)g_system->getEventManager()->pollEvent(event);
g_system->delayMillis(10);
}
g_system->hideOverlay();
splash = true;
}
void RivenGraphics::clearInventoryArea() {
// Clear the inventory area
static const Common::Rect inventoryRect = Common::Rect(0, 392, 608, 436);
// Lock the screen
Graphics::Surface *screen = _vm->_system->lockScreen();
// Fill the inventory area with black
screen->fillRect(inventoryRect, _pixelFormat.RGBToColor(0, 0, 0));
_vm->_system->unlockScreen();
}
Graphics::Surface *TruetypeFont::drawTextToSurface(const Common::String &text, uint16 textColor, int maxWidth, int maxHeight, Graphics::TextAlign align, bool wrap) {
if (text.equals("")) {
return nullptr;
}
Graphics::Surface *surface = new Graphics::Surface();
if (!wrap) {
int width = MIN(_font->getStringWidth(text), maxWidth);
surface->create(width, _lineHeight, Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0));
// TODO: Add better alpha support by getting the pixels from the backbuffer.
// However doing that requires some kind of caching system so future text doesn't try to use this text as it's alpha background.
surface->fillRect(Common::Rect(0, 0, surface->w, surface->h), 0);
_font->drawString(surface, text, 0, 0, maxWidth, textColor, align);
return surface;
}
Common::Array<Common::String> lines;
_font->wordWrapText(text, maxWidth, lines);
while (maxHeight > 0 && (int)lines.size() * _lineHeight > maxHeight) {
lines.pop_back();
}
if (lines.size() == 0) {
delete surface;
return nullptr;
}
surface->create(maxWidth, lines.size() * _lineHeight, Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0));
surface->fillRect(Common::Rect(0, 0, surface->w, surface->h), 0);
int heightOffset = 0;
for (Common::Array<Common::String>::iterator it = lines.begin(); it != lines.end(); it++) {
_font->drawString(surface, *it, 0, 0 + heightOffset, maxWidth, textColor, align);
heightOffset += _lineHeight;
}
return surface;
}
void Testsuite::clearScreen(bool flag) {
Graphics::Surface *screen = g_system->lockScreen();
uint fillColor = kColorBlack;
if (flag) {
fillColor = g_system->getScreenFormat().RGBToColor(0, 0, 0);
}
screen->fillRect(Common::Rect(0, 0, g_system->getWidth(), g_system->getHeight()), fillColor);
g_system->unlockScreen();
g_system->updateScreen();
}
/**
* Writes out a character at the currently set position using the active font
*
* @ch Character to display
*/
int GfxFont::writeChar(const char ch) {
assert((_fontData != NULL) && ((uint8)ch < _numChars));
uint32 charOffset = READ_LE_UINT32(_fontData + 12 + (uint8)ch * 4);
int charWidth = _fontData[charOffset] & 0x1f;
int charHeight = (READ_LE_UINT16(_fontData + charOffset) >> 5) & 0x3f;
int yOffset = (_fontData[charOffset + 1] >> 3) & 0x1f;
const uint8 *dataP = &_fontData[charOffset + 2];
// Lock the surface for access
Graphics::Surface surfacePtr = _gfxManager->lockSurface();
Rect charRect;
charRect.set(0, 0, charWidth, _fontSize.y);
charRect.translate(_topLeft.x + _position.x, _topLeft.y + _position.y + yOffset);
if (_fillFlag)
surfacePtr.fillRect(charRect, _colors.background);
charRect.bottom = charRect.top + charHeight;
// Display the character
int bitCtr = 0;
uint8 v = 0;
for (int yp = charRect.top; yp < charRect.bottom; ++yp) {
byte *destP = (byte *)surfacePtr.getBasePtr(charRect.left, yp);
for (int xs = 0; xs < charRect.width(); ++xs, ++destP) {
// Get the next color index to use
if ((bitCtr % 8) == 0) v = *dataP++;
int colIndex = 0;
for (int subCtr = 0; subCtr < _bpp; ++subCtr, ++bitCtr) {
colIndex = (colIndex << 1) | (v & 0x80 ? 1 : 0);
v <<= 1;
}
switch (colIndex) {
//case 0: *destP = _colors.background; break;
case 1: *destP = _colors.foreground; break;
case 2: *destP = _colors2.background; break;
case 3: *destP = _colors2.foreground; break;
}
}
}
_position.x += charWidth;
_gfxManager->unlockSurface();
return charWidth;
}
/**
* Show any active hotspot areas in the scene
*/
bool Debugger::Cmd_Hotspots(int argc, const char **argv) {
int colIndex = 16;
const Rect &sceneBounds = g_globals->_sceneManager._scene->_sceneBounds;
// Lock the background surface for access
Graphics::Surface destSurface = g_globals->_sceneManager._scene->_backSurface.lockSurface();
// Iterate through the scene items
SynchronizedList<SceneItem *>::iterator i;
for (i = g_globals->_sceneItems.reverse_begin(); i != g_globals->_sceneItems.end(); --i, ++colIndex) {
SceneItem *o = *i;
// Draw the contents of the hotspot area
if (o->_sceneRegionId == 0) {
// Scene item doesn't use a region, so fill in the entire area
if ((o->_bounds.right > o->_bounds.left) && (o->_bounds.bottom > o->_bounds.top))
destSurface.fillRect(Rect(o->_bounds.left - sceneBounds.left, o->_bounds.top - sceneBounds.top,
o->_bounds.right - sceneBounds.left - 1, o->_bounds.bottom - sceneBounds.top - 1), colIndex);
} else {
// Scene uses a region, so get it and use it to fill out only the correct parts
SceneRegions::iterator ri = g_globals->_sceneRegions.begin();
while ((ri != g_globals->_sceneRegions.end()) && ((*ri)._regionId != o->_sceneRegionId))
++ri;
if (ri != g_globals->_sceneRegions.end()) {
// Fill out the areas defined by the region
Region &r = *ri;
for (int y = r._bounds.top; y < r._bounds.bottom; ++y) {
LineSliceSet set = r.getLineSlices(y);
for (uint p = 0; p < set.items.size(); ++p)
destSurface.hLine(set.items[p].xs - sceneBounds.left, y - sceneBounds.top,
set.items[p].xe - sceneBounds.left - 1, colIndex);
}
}
}
}
// Release the surface
g_globals->_sceneManager._scene->_backSurface.unlockSurface();
// Mark the scene as requiring a full redraw
g_globals->_paneRefreshFlag[0] = 2;
return false;
}
static void drawProgress(float progress) {
const Graphics::Font &font(*FontMan.getFontByUsage(Graphics::FontManager::kOSDFont));
Graphics::Surface surf;
uint32 borderColor = 0x2;
uint32 fillColor = 0x4;
surf.w = g_system->getWidth() / 7 * 5;
surf.h = font.getFontHeight();
int x = g_system->getWidth() / 7;
int y = g_system->getHeight() / 2 - surf.h / 2;
surf.pitch = surf.w;
surf.bytesPerPixel = 1;
surf.pixels = calloc(surf.w, surf.h);
Common::Rect r(surf.w, surf.h);
surf.frameRect(r, borderColor);
r.grow(-1);
r.right = r.left + (uint16)(r.width() * progress);
surf.fillRect(r, fillColor);
g_system->copyRectToScreen((byte *)surf.pixels, surf.pitch, x, y, surf.w, surf.h);
g_system->updateScreen();
free(surf.pixels);
}
static void drawProgress(float progress) {
const Graphics::Font &font(*FontMan.getFontByUsage(Graphics::FontManager::kGUIFont));
Graphics::Surface *screen = g_system->lockScreen();
assert(screen);
assert(screen->pixels);
Graphics::PixelFormat screenFormat = g_system->getScreenFormat();
int16 w = g_system->getWidth() / 7 * 5;
int16 h = font.getFontHeight();
int16 x = g_system->getWidth() / 7;
int16 y = g_system->getHeight() / 2 - h / 2;
Common::Rect r(x, y, x + w, y + h);
uint32 col;
if (screenFormat.bytesPerPixel > 1)
col = screenFormat.RGBToColor(0, 171, 0);
else
col = 1;
screen->frameRect(r, col);
r.grow(-1);
r.setWidth(uint16(progress * w));
if (screenFormat.bytesPerPixel > 1)
col = screenFormat.RGBToColor(171, 0, 0);
else
col = 2;
screen->fillRect(r, col);
g_system->unlockScreen();
g_system->updateScreen();
}
/**
* Fills a specified rectangle on the surface with the specified color
*
* @bounds Area to fill
* @color Color to use
*/
void GfxSurface::fillRect(const Rect &bounds, int color) {
Graphics::Surface surface = lockSurface();
surface.fillRect(bounds, color);
unlockSurface();
}
bool TeenAgentEngine::showMetropolis() {
_system->fillScreen(0);
_system->updateScreen();
FilePack varia;
varia.open("varia.res");
byte palette[0x400];
memset(palette, 0, sizeof(palette));
{
Common::ScopedPtr<Common::SeekableReadStream> s(varia.getStream(5));
for(uint c = 0; c < 0x400; c += 4) {
s->read(palette + c, 3);
palette[c] *= 4;
palette[c + 1] *= 4;
palette[c + 2] *= 4;
}
}
_system->setPalette(palette, 0, 0x100);
byte varia_6[21760], varia_9[18302];
varia.read(6, varia_6, sizeof(varia_6));
varia.read(9, varia_9, sizeof(varia_9));
byte colors[56 * 160 * 2];
memset(colors, 0, sizeof(colors));
int logo_y = -56;
for(uint f = 0; f < 300; ++f) {
{
int r = skipEvents();
if (r != 0)
return r > 0? true: false;
}
Graphics::Surface *surface = _system->lockScreen();
if (logo_y > 0) {
surface->fillRect(Common::Rect(0, 0, 320, logo_y), 0);
}
{
//generate colors matrix
memmove(colors + 320, colors + 480, 8480);
for(uint c = 0; c < 17; ++c) {
byte x = (random.getRandomNumber(184) + 5) & 0xff;
uint offset = 8800 + random.getRandomNumber(158);
colors[offset++] = x;
colors[offset++] = x;
}
for(uint y = 1; y < 56; ++y) {
for(uint x = 1; x < 160; ++x) {
uint offset = y * 160 + x;
uint v =
(uint)colors[offset - 161] + colors[offset - 160] + colors[offset - 159] +
(uint)colors[offset - 1] + colors[offset + 1] +
(uint)colors[offset + 161] + colors[offset + 160] + colors[offset + 159];
v >>= 3;
colors[offset + 8960] = v;
}
}
memmove(colors, colors + 8960, 8960);
}
byte *dst = (byte *)surface->getBasePtr(0, 131);
byte *src = varia_6;
for(uint y = 0; y < 68; ++y) {
for(uint x = 0; x < 320; ++x) {
if (*src++ == 1) {
*dst++ = colors[19 * 160 + y / 2 * 160 + x / 2];
} else
++dst;
}
}
_system->unlockScreen();
_system->copyRectToScreen(
varia_9 + (logo_y < 0? -logo_y * 320: 0), 320,
0, logo_y >= 0? logo_y: 0,
320, logo_y >= 0? 57: 57 + logo_y);
if (logo_y < 82 - 57)
++logo_y;
_system->updateScreen();
_system->delayMillis(100);
}
return true;
}
void OpenGLGraphicsManager::osdMessageUpdateSurface() {
// Split up the lines.
Common::Array<Common::String> osdLines;
Common::StringTokenizer tokenizer(_osdMessageNextData, "\n");
while (!tokenizer.empty()) {
osdLines.push_back(tokenizer.nextToken());
}
// Do the actual drawing like the SDL backend.
const Graphics::Font *font = getFontOSD();
// Determine a rect which would contain the message string (clipped to the
// screen dimensions).
const int vOffset = 6;
const int lineSpacing = 1;
const int lineHeight = font->getFontHeight() + 2 * lineSpacing;
uint width = 0;
uint height = lineHeight * osdLines.size() + 2 * vOffset;
for (uint i = 0; i < osdLines.size(); i++) {
width = MAX<uint>(width, font->getStringWidth(osdLines[i]) + 14);
}
// Clip the rect
width = MIN<uint>(width, _displayWidth);
height = MIN<uint>(height, _displayHeight);
delete _osdMessageSurface;
_osdMessageSurface = nullptr;
_osdMessageSurface = createSurface(_defaultFormatAlpha);
assert(_osdMessageSurface);
// We always filter the osd with GL_LINEAR. This assures it's
// readable in case it needs to be scaled and does not affect it
// otherwise.
_osdMessageSurface->enableLinearFiltering(true);
_osdMessageSurface->allocate(width, height);
Graphics::Surface *dst = _osdMessageSurface->getSurface();
// Draw a dark gray rect.
const uint32 color = dst->format.RGBToColor(40, 40, 40);
dst->fillRect(Common::Rect(0, 0, width, height), color);
// Render the message in white
const uint32 white = dst->format.RGBToColor(255, 255, 255);
for (uint i = 0; i < osdLines.size(); ++i) {
font->drawString(dst, osdLines[i],
0, i * lineHeight + vOffset + lineSpacing, width,
white, Graphics::kTextAlignCenter);
}
_osdMessageSurface->updateGLTexture();
// Init the OSD display parameters.
_osdMessageAlpha = kOSDMessageInitialAlpha;
_osdMessageFadeStartTime = g_system->getMillis() + kOSDMessageFadeOutDelay;
// Clear the text update request
_osdMessageNextData.clear();
_osdMessageChangeRequest = false;
}
virtual void clearOverlay()
{
_overlay.fillRect(Common::Rect(_overlay.w, _overlay.h), 0);
}