void PicButtonWidget::drawWidget() {
if (_showButton)
g_gui.theme()->drawButton(Common::Rect(_x, _y, _x + _w, _y + _h), "", _state, getFlags());
Graphics::Surface *gfx;
if (_state == ThemeEngine::kStateHighlight)
gfx = &_gfx[kPicButtonHighlight];
else if (_state == ThemeEngine::kStateDisabled)
gfx = &_gfx[kPicButtonStateDisabled];
else if (_state == ThemeEngine::kStatePressed)
gfx = &_gfx[kPicButtonStatePressed];
else
gfx = &_gfx[kPicButtonStateEnabled];
if (!gfx->getPixels())
gfx = &_gfx[kPicButtonStateEnabled];
if (gfx->getPixels()) {
// Check whether the set up surface needs to be converted to the GUI
// color format.
const Graphics::PixelFormat &requiredFormat = g_gui.theme()->getPixelFormat();
if (gfx->format != requiredFormat) {
gfx->convertToInPlace(requiredFormat);
}
const int x = _x + (_w - gfx->w) / 2;
const int y = _y + (_h - gfx->h) / 2;
g_gui.theme()->drawSurface(Common::Rect(x, y, x + gfx->w, y + gfx->h), *gfx, _transparency);
}
}
void CTargaDecode::decode(OSVideoSurface &surface, const CString &name) {
// Open up the resource
StdCWadFile file;
file.open(name);
// Use the ScucmmVM deoder to decode it
loadStream(*file.readStream());
const Graphics::Surface *srcSurf = getSurface();
// Resize the surface if necessary
if (!surface.hasSurface() || surface.getWidth() != srcSurf->w
|| surface.getHeight() != srcSurf->h)
surface.recreate(srcSurf->w, srcSurf->h);
// Convert the decoded surface to the correct pixel format, and then copy it over
surface.lock();
Graphics::Surface *convertedSurface = srcSurf->convertTo(surface._rawSurface->format);
Common::copy((byte *)convertedSurface->getPixels(), (byte *)convertedSurface->getPixels() +
surface.getPitch() * surface.getHeight(), (byte *)surface._rawSurface->getPixels());
convertedSurface->free();
delete convertedSurface;
surface.unlock();
}
void MystCursorManager::setCursor(uint16 id) {
// Zero means empty cursor
if (id == 0) {
static const byte emptyCursor[4] = { 0, 0, 0, 0 };
CursorMan.replaceCursor(&emptyCursor, 2, 2, 0, 0, 0);
return;
}
// Both Myst and Myst ME use the "MystBitmap" format for cursor images.
MohawkSurface *mhkSurface = _bmpDecoder->decodeImage(_vm->getResource(ID_WDIB, id));
Graphics::Surface *surface = mhkSurface->getSurface();
Common::SeekableReadStream *clrcStream = _vm->getResource(ID_CLRC, id);
uint16 hotspotX = clrcStream->readUint16LE();
uint16 hotspotY = clrcStream->readUint16LE();
delete clrcStream;
// Myst ME stores some cursors as 24bpp images instead of 8bpp
if (surface->format.bytesPerPixel == 1) {
CursorMan.replaceCursor(surface->getPixels(), surface->w, surface->h, hotspotX, hotspotY, 0);
CursorMan.replaceCursorPalette(mhkSurface->getPalette(), 0, 256);
} else {
Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
CursorMan.replaceCursor(surface->getPixels(), surface->w, surface->h, hotspotX, hotspotY, pixelFormat.RGBToColor(255, 255, 255), false, &pixelFormat);
}
_vm->_needsUpdate = true;
delete mhkSurface;
}
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 RenderManager::blitSurfaceToBkgScaled(const Graphics::Surface &src, const Common::Rect &_dstRect, int32 colorkey) {
if (src.w == _dstRect.width() && src.h == _dstRect.height()) {
blitSurfaceToBkg(src, _dstRect.left, _dstRect.top, colorkey);
} else {
Graphics::Surface *tmp = new Graphics::Surface;
tmp->create(_dstRect.width(), _dstRect.height(), src.format);
scaleBuffer(src.getPixels(), tmp->getPixels(), src.w, src.h, src.format.bytesPerPixel, _dstRect.width(), _dstRect.height());
blitSurfaceToBkg(*tmp, _dstRect.left, _dstRect.top, colorkey);
tmp->free();
delete tmp;
}
}
void Events::setCursor(const Graphics::Surface &src, int hotspotX, int hotspotY) {
_cursorId = INVALID_CURSOR;
_hotspotPos = Common::Point(hotspotX, hotspotY);
if (!IS_3DO) {
// PC 8-bit palettized
CursorMan.replaceCursor(src.getPixels(), src.w, src.h, hotspotX, hotspotY, 0xff);
} else {
// 3DO RGB565
CursorMan.replaceCursor(src.getPixels(), src.w, src.h, hotspotX, hotspotY, 0x0000, false, &src.format);
}
showCursor();
}
void EventsManager::setCursor(CursorType cursorId) {
if (cursorId == _cursorId)
return;
_cursorId = cursorId;
if (cursorId == CURSOR_INVENTORY) {
// Set the cursor
CursorMan.replaceCursor(_invCursor.getPixels(), _invCursor.w, _invCursor.h,
_invCursor.w / 2, _invCursor.h / 2, 0);
} else {
// Get a pointer to the mouse data to use, and get the cursor hotspot
const byte *srcP = Amazon::CURSORS[cursorId];
int hotspotX = (int16)READ_LE_UINT16(srcP);
int hotspotY = (int16)READ_LE_UINT16(srcP + 2);
srcP += 4;
// Create a surface to build up the cursor on
Graphics::Surface cursorSurface;
cursorSurface.create(16, 16, Graphics::PixelFormat::createFormatCLUT8());
byte *destP = (byte *)cursorSurface.getPixels();
Common::fill(destP, destP + CURSOR_WIDTH * CURSOR_HEIGHT, 0);
// Loop to build up the cursor
for (int y = 0; y < CURSOR_HEIGHT; ++y) {
destP = (byte *)cursorSurface.getBasePtr(0, y);
int width = CURSOR_WIDTH;
int skip = *srcP++;
int plot = *srcP++;
if (skip >= width)
break;
// Skip over pixels
destP += skip;
width -= skip;
// Write out the pixels to plot
while (plot > 0 && width > 0) {
*destP++ = *srcP++;
--plot;
--width;
}
}
// Set the cursor
CursorMan.replaceCursor(cursorSurface.getPixels(), CURSOR_WIDTH, CURSOR_HEIGHT,
hotspotX, hotspotY, 0);
// Free the cursor surface
cursorSurface.free();
}
}
bool BitmapData::loadTGA(Common::SeekableReadStream *data) {
Image::TGADecoder dec;
bool success = dec.loadStream(*data);
if (!success)
return false;
const Graphics::Surface *origSurf = dec.getSurface();
Graphics::PixelFormat pixelFormat = Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24);
Graphics::Surface *surf = origSurf->convertTo(pixelFormat);
_width = surf->w;
_height = surf->h;
_format = 1;
_x = _y = 0;
_bpp = 4;
_colorFormat = BM_RGBA;
_numImages = 1;
_data = new Graphics::PixelBuffer[1];
_data[0].set(pixelFormat, (unsigned char *)surf->getPixels());
g_driver->createBitmap(this);
freeData();
delete surf;
return true;
}
void Mouse::updateCursor() {
if (!_surface)
return;
if (_doDeltaX) {
_surface->getDrawRect().x = filterX(_x - _drawOffset.width - _drawOffset.x + 1);
} else {
_surface->getDrawRect().x = filterX(_x + _drawOffset.x);
}
if (_doDeltaY) {
_surface->getDrawRect().y = filterY(_y - _drawOffset.height - _drawOffset.y + 1);
} else {
_surface->getDrawRect().y = filterY(_y + _drawOffset.y);
}
if (_needRefresh) {
_needRefresh = false;
_drawOffset = _mouseCursorResource.getRect();
_surface->drawMouseCursorResource(_mouseCursorResource, _frameNum / 2);
Graphics::Surface *cursorSurface = _surface->getSurface();
CursorMan.replaceCursor((const byte*)cursorSurface->getPixels(),
cursorSurface->w, cursorSurface->h, -_drawOffset.x, -_drawOffset.y, 0);
}
}
Graphics::Surface *TinyGLRenderer::getScreenshot() {
Graphics::Surface *s = new Graphics::Surface();
s->create(kOriginalWidth, kOriginalHeight, Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24));
Graphics::PixelBuffer buf(s->format, (byte *)s->getPixels());
_fb->copyToBuffer(buf);
return s;
}
// BiffObject API
void readData(ArchiveReadStream *stream, uint32 dataLength) override {
TextureGroup *textureGroup = static_cast<TextureGroup *>(_parent);
_name = stream->readString16();
_u = stream->readByte();
uint32 w = stream->readUint32LE();
uint32 h = stream->readUint32LE();
uint32 levels = stream->readUint32LE();
_texture = StarkGfx->createTexture();
_texture->setLevelCount(levels);
for (uint32 i = 0; i < levels; ++i) {
// Read the pixel data to a surface
Graphics::Surface level;
level.create(w, h, Graphics::PixelFormat::createFormatCLUT8());
stream->read(level.getPixels(), level.w * level.h);
// Add the mipmap level to the texture
_texture->addLevel(i, &level, textureGroup->getPalette());
level.free();
w /= 2;
h /= 2;
}
}
void DrasculaEngine::showFrame(Common::SeekableReadStream *stream, bool firstFrame) {
int dataSize = stream->readSint32LE();
byte *pcxData = (byte *)malloc(dataSize);
stream->read(pcxData, dataSize);
for (int i = 0; i < 256; i++) {
cPal[i * 3 + 0] = stream->readByte();
cPal[i * 3 + 1] = stream->readByte();
cPal[i * 3 + 2] = stream->readByte();
}
byte *prevFrame = (byte *)malloc(64000);
Graphics::Surface *screenSurf = _system->lockScreen();
byte *screenBuffer = (byte *)screenSurf->getPixels();
uint16 screenPitch = screenSurf->pitch;
for (int y = 0; y < 200; y++) {
memcpy(prevFrame+y*320, screenBuffer+y*screenPitch, 320);
}
decodeRLE(pcxData, screenBuffer, screenPitch);
free(pcxData);
if (!firstFrame)
mixVideo(screenBuffer, prevFrame, screenPitch);
_system->unlockScreen();
_system->updateScreen();
if (firstFrame)
setPalette(cPal);
free(prevFrame);
}
void CGEEngine::writeSavegameHeader(Common::OutSaveFile *out, SavegameHeader &header) {
// Write out a savegame header
out->write(savegameStr, kSavegameStrSize + 1);
out->writeByte(kSavegameVersion);
// Write savegame name
out->write(header.saveName.c_str(), header.saveName.size() + 1);
// Get the active palette
uint8 thumbPalette[256 * 3];
g_system->getPaletteManager()->grabPalette(thumbPalette, 0, 256);
// Create a thumbnail and save it
Graphics::Surface *thumb = new Graphics::Surface();
Graphics::Surface *s = _vga->_page[0];
::createThumbnail(thumb, (const byte *)s->getPixels(), kScrWidth, kScrHeight, thumbPalette);
Graphics::saveThumbnail(*out, *thumb);
thumb->free();
delete thumb;
// Write out the save date/time
TimeDate td;
g_system->getTimeAndDate(td);
out->writeSint16LE(td.tm_year + 1900);
out->writeSint16LE(td.tm_mon + 1);
out->writeSint16LE(td.tm_mday);
out->writeSint16LE(td.tm_hour);
out->writeSint16LE(td.tm_min);
}
void Saver::writeSavegameHeader(Common::OutSaveFile *out, tSageSavegameHeader &header) {
// Write out a savegame header
out->write(SAVEGAME_STR, SAVEGAME_STR_SIZE + 1);
out->writeByte(TSAGE_SAVEGAME_VERSION);
// Write savegame name
out->write(header.saveName.c_str(), header.saveName.size() + 1);
// Get the active palette
uint8 thumbPalette[256 * 3];
g_system->getPaletteManager()->grabPalette(thumbPalette, 0, 256);
// Create a thumbnail and save it
Graphics::Surface *thumb = new Graphics::Surface();
Graphics::Surface s = g_globals->_screenSurface.lockSurface();
::createThumbnail(thumb, (const byte *)s.getPixels(), SCREEN_WIDTH, SCREEN_HEIGHT, thumbPalette);
Graphics::saveThumbnail(*out, *thumb);
g_globals->_screenSurface.unlockSurface();
thumb->free();
delete thumb;
// Write out the save date/time
TimeDate td;
g_system->getTimeAndDate(td);
out->writeSint16LE(td.tm_year + 1900);
out->writeSint16LE(td.tm_mon + 1);
out->writeSint16LE(td.tm_mday);
out->writeSint16LE(td.tm_hour);
out->writeSint16LE(td.tm_min);
out->writeUint32LE(g_globals->_events.getFrameNumber());
}
bool MoviePlayerDXA::processFrame() {
Graphics::Surface *screen = _vm->_system->lockScreen();
copyFrameToBuffer((byte *)screen->getPixels(), (_vm->_screenWidth - getWidth()) / 2, (_vm->_screenHeight - getHeight()) / 2, screen->pitch);
_vm->_system->unlockScreen();
uint32 soundTime = _mixer->getSoundElapsedTime(_bgSound);
uint32 nextFrameStartTime = ((Video::VideoDecoder::VideoTrack *)getTrack(0))->getNextFrameStartTime();
if ((_bgSoundStream == NULL) || soundTime < nextFrameStartTime) {
if (_bgSoundStream && _mixer->isSoundHandleActive(_bgSound)) {
while (_mixer->isSoundHandleActive(_bgSound) && soundTime < nextFrameStartTime) {
_vm->_system->delayMillis(10);
soundTime = _mixer->getSoundElapsedTime(_bgSound);
}
// In case the background sound ends prematurely, update
// _ticks so that we can still fall back on the no-sound
// sync case for the subsequent frames.
_ticks = _vm->_system->getMillis();
} else {
_ticks += getTimeToNextFrame();
while (_vm->_system->getMillis() < _ticks)
_vm->_system->delayMillis(10);
}
return true;
}
warning("dropped frame %i", getCurFrame());
return false;
}
Graphics::Surface *Menu::createThumbnail(Graphics::Surface *big) {
assert(big->format.bytesPerPixel == 4);
Graphics::Surface *small = new Graphics::Surface();
small->create(GameState::kThumbnailWidth, GameState::kThumbnailHeight,
Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24));
uint bigHeight = big->h - Renderer::kTopBorderHeight - Renderer::kBottomBorderHeight;
uint bigYOffset = Renderer::kBottomBorderHeight;
uint32 *dst = (uint32 *)small->getPixels();
for (uint i = 0; i < small->h; i++) {
for (uint j = 0; j < small->w; j++) {
uint32 srcX = big->w * j / small->w;
uint32 srcY = bigYOffset + bigHeight - bigHeight * i / small->h;
uint32 *src = (uint32 *)big->getBasePtr(srcX, srcY - 1);
// Copy RGBA pixel
*dst++ = *src;
}
}
// The thumbnail is stored on disk in BGRA
small->convertToInPlace(Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24));
return small;
}
Graphics::Surface *ShaderRenderer::getScreenshot() {
Graphics::Surface *s = new Graphics::Surface();
s->create(kOriginalWidth, kOriginalHeight, Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24));
glReadPixels(0, 0, kOriginalWidth, kOriginalHeight, GL_RGBA, GL_UNSIGNED_BYTE, s->getPixels());
return s;
}
void AGOSEngine::vc61() {
uint16 a = vcReadNextWord();
byte *src, *dst, *dstPtr;
uint h, tmp;
Graphics::Surface *screen = _system->lockScreen();
dstPtr = (byte *)screen->getPixels();
if (a == 6) {
src = _curVgaFile2 + 800;
dst = dstPtr;
for (int i = 0; i < _screenHeight; i++) {
memcpy(dst, src, _screenWidth);
src += 320;
dst += screen->pitch;
}
tmp = 4 - 1;
} else {
tmp = a - 1;
}
src = _curVgaFile2 + 3840 * 16 + 3360;
while (tmp--)
src += 1536 * 16 + 1712;
src += 800;
if (a != 5) {
dst = dstPtr + 23 * screen->pitch + 88;
for (h = 0; h < 177; h++) {
memcpy(dst, src, 144);
src += 144;
dst += screen->pitch;
}
if (a != 6) {
_system->unlockScreen();
return;
}
src = _curVgaFile2 + 9984 * 16 + 15344;
}
dst = dstPtr + 157 * screen->pitch + 56;
for (h = 0; h < 17; h++) {
memcpy(dst, src, 208);
src += 208;
dst += screen->pitch;
}
_system->unlockScreen();
if (a == 6)
fullFade();
}
void RivenGraphics::drawInventoryImage(uint16 id, const Common::Rect *rect) {
MohawkSurface *mhkSurface = _bitmapDecoder->decodeImage(_vm->getExtrasResource(ID_TBMP, id));
mhkSurface->convertToTrueColor();
Graphics::Surface *surface = mhkSurface->getSurface();
_vm->_system->copyRectToScreen(surface->getPixels(), surface->pitch, rect->left, rect->top, surface->w, surface->h);
delete mhkSurface;
}
bool EventRecorder::grabScreenAndComputeMD5(Graphics::Surface &screen, uint8 md5[16]) {
if (!createScreenShot(screen)) {
warning("Can't save screenshot");
return false;
}
Common::MemoryReadStream bitmapStream((const byte*)screen.getPixels(), screen.w * screen.h * screen.format.bytesPerPixel);
computeStreamMD5(bitmapStream, md5);
return true;
}
void EventsClass::setCursor(GfxSurface &cursor) {
Graphics::Surface s = cursor.lockSurface();
const byte *cursorData = (const byte *)s.getPixels();
CursorMan.replaceCursor(cursorData, cursor.getBounds().width(), cursor.getBounds().height(),
cursor._centroid.x, cursor._centroid.y, cursor._transColor);
_lastCursor = CURSOR_NONE;
}
bool Console::cmdDumpImage(int argc, const char **argv) {
if (argc != 2) {
debugPrintf("Use %s <TGA/TGZ name> to dump a Z-Vision TGA/TGZ image into a regular BMP image\n", argv[0]);
return true;
}
Common::String fileName = argv[1];
if (!fileName.hasSuffix(".tga")) {
debugPrintf("%s is not an image file", argv[1]);
}
Common::File f;
if (!_engine->getSearchManager()->openFile(f, argv[1])) {
warning("File not found: %s", argv[1]);
return true;
}
Graphics::Surface surface;
_engine->getRenderManager()->readImageToSurface(argv[1], surface, false);
// Open file
Common::DumpFile out;
fileName.setChar('b', fileName.size() - 3);
fileName.setChar('m', fileName.size() - 2);
fileName.setChar('p', fileName.size() - 1);
out.open(fileName);
// Write BMP header
out.writeByte('B');
out.writeByte('M');
out.writeUint32LE(surface.h * surface.pitch + 54);
out.writeUint32LE(0);
out.writeUint32LE(54);
out.writeUint32LE(40);
out.writeUint32LE(surface.w);
out.writeUint32LE(surface.h);
out.writeUint16LE(1);
out.writeUint16LE(16);
out.writeUint32LE(0);
out.writeUint32LE(0);
out.writeUint32LE(0);
out.writeUint32LE(0);
out.writeUint32LE(0);
out.writeUint32LE(0);
// Write pixel data to BMP
out.write(surface.getPixels(), surface.pitch * surface.h);
out.flush();
out.close();
surface.free();
return true;
}
int16 ScriptFunctions::sfLoadMouseCursor(int16 argc, int16 *argv) {
PictureResource *flex = _vm->_res->getPicture(argv[2]);
if (flex) {
Graphics::Surface *surf = flex->getPicture();
CursorMan.replaceCursor(surf->getPixels(), surf->getWidth(), surf->getHeight(), argv[1], argv[0], 0);
_vm->_res->freeResource(flex);
}
return 0;
}
bool BladeRunnerEngine::saveGame(Common::WriteStream &stream, const Graphics::Surface &thumbnail) {
if (!playerHasControl() || _sceneScript->isInsideScript() || _aiScripts->isInsideScript()) {
return false;
}
Common::MemoryWriteStreamDynamic memoryStream(DisposeAfterUse::YES);
SaveFileWriteStream s(memoryStream);
s.write(thumbnail.getPixels(), SaveFileManager::kThumbnailSize);
s.writeFloat(1.0f);
_settings->save(s);
_scene->save(s);
_scene->_exits->save(s);
_scene->_regions->save(s);
_scene->_set->save(s);
for (uint i = 0; i != _gameInfo->getGlobalVarCount(); ++i) {
s.writeInt(_gameVars[i]);
}
_music->save(s);
// _audioPlayer->save(s) // zero func
// _audioSpeech->save(s) // zero func
_combat->save(s);
_gameFlags->save(s);
_items->save(s);
_sceneObjects->save(s);
_ambientSounds->save(s);
_overlays->save(s);
_spinner->save(s);
_scores->save(s);
_dialogueMenu->save(s);
_obstacles->save(s);
_actorDialogueQueue->save(s);
_waypoints->save(s);
for (uint i = 0; i != _gameInfo->getActorCount(); ++i) {
_actors[i]->save(s);
int animationState, animationFrame, animationStateNext, nextAnimation;
_aiScripts->queryAnimationState(i, &animationState, &animationFrame, &animationStateNext, &nextAnimation);
s.writeInt(animationState);
s.writeInt(animationFrame);
s.writeInt(animationStateNext);
s.writeInt(nextAnimation);
}
_actors[kActorVoiceOver]->save(s);
_policeMaze->save(s);
_crimesDatabase->save(s);
s.finalize();
stream.writeUint32LE(memoryStream.size() + 4);
stream.write(memoryStream.getData(), memoryStream.size());
stream.flush();
return true;
}
Graphics::Surface *OSystem_Android::lockScreen() {
ENTER();
GLTHREADCHECK;
Graphics::Surface *surface = _game_texture->surface();
assert(surface->getPixels());
return surface;
}
Graphics::Surface *OpenGLSDriver::getViewportScreenshot() const {
Graphics::Surface *s = new Graphics::Surface();
s->create(_viewport.width(), _viewport.height(), getRGBAPixelFormat());
glReadPixels(_viewport.left, g_system->getHeight() - _viewport.bottom, _viewport.width(), _viewport.height(),
GL_RGBA, GL_UNSIGNED_BYTE, s->getPixels());
flipVertical(s);
return s;
}
void Animation::drawFrameWithMaskAndScale(Graphics::Surface &surface, int32 frame, int16 xx, int16 yy, int32 zz, Picture *mask, int32 scale) {
debugC(5, kDebugAnim, "drawFrameWithMaskAndScale(surface, %d, %d, %d, %d, mask, %d)", frame, xx, yy, zz, scale);
int16 dataFrame = frame;
if (_frames[frame]._ref != -1)
dataFrame = _frames[frame]._ref;
int16 rectX = _frames[frame]._x2 - _frames[frame]._x1;
int16 rectY = _frames[frame]._y2 - _frames[frame]._y1;
int16 finalWidth = rectX * scale / 1024;
int16 finalHeight = rectY * scale / 1024;
// compute final x1, y1, x2, y2
int16 xx1 = xx + _x1 + _frames[frame]._x1 * scale / 1024;
int16 yy1 = yy + _y1 + _frames[frame]._y1 * scale / 1024;
int16 xx2 = xx1 + finalWidth;
int16 yy2 = yy1 + finalHeight;
int16 w = _frames[frame]._x2 - _frames[frame]._x1;
_vm->addDirtyRect(xx1, yy1, xx2, yy2);
int32 destPitch = surface.getPitch();
int32 destPitchMask = mask->getWidth();
uint8 *c = _frames[dataFrame]._data;
uint8 *curRow = (uint8 *)surface.getPixels();
uint8 *curRowMask = mask->getDataPtr();
bool shadowFlag = false;
if (strstr(_name, "SHADOW"))
shadowFlag = true;
for (int16 y = yy1; y < yy2; y++) {
for (int16 x = xx1; x < xx2; x++) {
if (x < 0 || x >= 1280 || y < 0 || y >= 400)
continue;
uint8 *cur = curRow + x + y * destPitch;
uint8 *curMask = curRowMask + x + y * destPitchMask;
// find the good c
int16 xs = (x - xx1) * 1024 / scale;
int16 ys = (y - yy1) * 1024 / scale;
uint8 *cc = &c[ys * w + xs];
if (*cc && ((*curMask) >= zz)) {
if (shadowFlag)
*cur = _vm->getShadowLUT()[*cur];
else
*cur = *cc;
}
}
}
}
void AGOSEngine::fillBackGroundFromFront() {
Graphics::Surface *screen = _system->lockScreen();
byte *src = (byte *)screen->getPixels();
byte *dst = getBackGround();
for (int i = 0; i < _screenHeight; i++) {
memcpy(dst, src, _screenWidth);
src += screen->getPitch();
dst += _backGroundBuf->getPitch();
}
_system->unlockScreen();
}
void MystCursorManager::setCursor(uint16 id) {
// Zero means empty cursor
if (id == 0) {
static const byte emptyCursor[4] = { 0, 0, 0, 0 };
CursorMan.replaceCursor(&emptyCursor, 2, 2, 0, 0, 0);
return;
}
Common::SeekableReadStream *clrcStream = _vm->getResource(ID_CLRC, id);
uint16 hotspotX = clrcStream->readUint16LE();
uint16 hotspotY = clrcStream->readUint16LE();
delete clrcStream;
// Both Myst and Myst ME use the "MystBitmap" format for cursor images.
MohawkSurface *mhkSurface = _vm->_gfx->findImage(id);
Graphics::Surface *surface = mhkSurface->getSurface();
// Myst ME stores some cursors as 24bpp images instead of 8bpp
if (surface->format.bytesPerPixel == 1) {
// The transparent color is almost always 255, except for the main cursor (100)
// in the D'ni archive, where it is 0.
// Using the color of the first pixel as the transparent color for the main cursor always works.
byte transparentColor;
if (id == kDefaultMystCursor) {
transparentColor = ((byte *)surface->getPixels())[0];
} else {
transparentColor = 255;
}
CursorMan.replaceCursor(surface->getPixels(), surface->w, surface->h, hotspotX, hotspotY, transparentColor);
// We're using the screen palette for the original game, but we need
// to use this for any 8bpp cursor in ME.
if (_vm->getFeatures() & GF_ME)
CursorMan.replaceCursorPalette(mhkSurface->getPalette(), 0, 256);
} else {
Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
CursorMan.replaceCursor(surface->getPixels(), surface->w, surface->h, hotspotX, hotspotY, pixelFormat.RGBToColor(255, 255, 255), false, &pixelFormat);
}
}
void EventsClass::pushCursor(CursorType cursorType) {
const byte *cursor;
bool delFlag = true;
uint size;
switch (cursorType) {
case CURSOR_NONE:
// No cursor
cursor = g_resourceManager->getSubResource(4, 1, 6, &size);
break;
case CURSOR_LOOK:
// Look cursor
cursor = g_resourceManager->getSubResource(4, 1, 5, &size);
break;
case CURSOR_USE:
// Use cursor
cursor = g_resourceManager->getSubResource(4, 1, 4, &size);
break;
case CURSOR_TALK:
// Talk cursor
cursor = g_resourceManager->getSubResource(4, 1, 3, &size);
break;
case CURSOR_ARROW:
// Arrow cursor
cursor = CURSOR_ARROW_DATA;
delFlag = false;
break;
case CURSOR_WALK:
default:
// Walk cursor
cursor = CURSOR_WALK_DATA;
delFlag = false;
break;
}
// Decode the cursor
GfxSurface s = surfaceFromRes(cursor);
Graphics::Surface surface = s.lockSurface();
const byte *cursorData = (const byte *)surface.getPixels();
CursorMan.pushCursor(cursorData, surface.w, surface.h, s._centroid.x, s._centroid.y, s._transColor);
s.unlockSurface();
if (delFlag)
DEALLOCATE(cursor);
}