Initial commit
This commit is contained in:
375
engines/sherlock/screen.cpp
Normal file
375
engines/sherlock/screen.cpp
Normal file
@@ -0,0 +1,375 @@
|
||||
/* ScummVM - Graphic Adventure Engine
|
||||
*
|
||||
* ScummVM is the legal property of its developers, whose names
|
||||
* are too numerous to list here. Please refer to the COPYRIGHT
|
||||
* file distributed with this source distribution.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "sherlock/screen.h"
|
||||
#include "sherlock/sherlock.h"
|
||||
#include "sherlock/scalpel/scalpel_screen.h"
|
||||
#include "sherlock/scalpel/3do/scalpel_3do_screen.h"
|
||||
#include "sherlock/tattoo/tattoo_screen.h"
|
||||
#include "common/system.h"
|
||||
#include "common/util.h"
|
||||
#include "graphics/palette.h"
|
||||
|
||||
namespace Sherlock {
|
||||
|
||||
Screen *Screen::init(SherlockEngine *vm) {
|
||||
if (vm->getGameID() == GType_RoseTattoo)
|
||||
return new Tattoo::TattooScreen(vm);
|
||||
else if (vm->getPlatform() == Common::kPlatform3DO)
|
||||
return new Scalpel::Scalpel3DOScreen(vm);
|
||||
else
|
||||
return new Scalpel::ScalpelScreen(vm);
|
||||
}
|
||||
|
||||
Screen::Screen(SherlockEngine *vm) : BaseSurface(), _vm(vm),
|
||||
_backBuffer1(vm->getGameID() == GType_RoseTattoo ? 640 : 320, vm->getGameID() == GType_RoseTattoo ? 480 : 200),
|
||||
_backBuffer2(vm->getGameID() == GType_RoseTattoo ? 640 : 320, vm->getGameID() == GType_RoseTattoo ? 480 : 200) {
|
||||
_transitionSeed = 1;
|
||||
_fadeStyle = false;
|
||||
Common::fill(&_cMap[0], &_cMap[Graphics::PALETTE_SIZE], 0);
|
||||
Common::fill(&_sMap[0], &_sMap[Graphics::PALETTE_SIZE], 0);
|
||||
Common::fill(&_tMap[0], &_tMap[Graphics::PALETTE_SIZE], 0);
|
||||
|
||||
// Set up the initial font
|
||||
setFont(IS_SERRATED_SCALPEL ? 1 : 4);
|
||||
|
||||
// Rose Tattoo specific fields
|
||||
_fadeBytesRead = _fadeBytesToRead = 0;
|
||||
_oldFadePercent = 0;
|
||||
_flushScreen = false;
|
||||
|
||||
create(g_system->getWidth(), g_system->getHeight(), g_system->getScreenFormat());
|
||||
_backBuffer.create(_backBuffer1, _backBuffer1.getBounds());
|
||||
}
|
||||
|
||||
Screen::~Screen() {
|
||||
Fonts::freeFont();
|
||||
}
|
||||
|
||||
void Screen::activateBackBuffer1() {
|
||||
_backBuffer.create(_backBuffer1, _backBuffer1.getBounds());
|
||||
}
|
||||
|
||||
void Screen::activateBackBuffer2() {
|
||||
_backBuffer.create(_backBuffer2, _backBuffer2.getBounds());
|
||||
}
|
||||
|
||||
int Screen::equalizePalette(const byte palette[Graphics::PALETTE_SIZE]) {
|
||||
int total = 0;
|
||||
byte tempPalette[Graphics::PALETTE_SIZE];
|
||||
getPalette(tempPalette);
|
||||
|
||||
// For any palette component that doesn't already match the given destination
|
||||
// palette, change by 1 towards the reference palette component
|
||||
for (int idx = 0; idx < Graphics::PALETTE_SIZE; ++idx) {
|
||||
if (tempPalette[idx] > palette[idx]) {
|
||||
tempPalette[idx] = MAX((int)palette[idx], (int)tempPalette[idx] - 4);
|
||||
++total;
|
||||
} else if (tempPalette[idx] < palette[idx]) {
|
||||
tempPalette[idx] = MIN((int)palette[idx], (int)tempPalette[idx] + 4);
|
||||
++total;
|
||||
}
|
||||
}
|
||||
|
||||
if (total > 0)
|
||||
// Palette changed, so reload it
|
||||
setPalette(tempPalette);
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
void Screen::fadeToBlack(int speed) {
|
||||
byte tempPalette[Graphics::PALETTE_SIZE];
|
||||
Common::fill(&tempPalette[0], &tempPalette[Graphics::PALETTE_SIZE], 0);
|
||||
|
||||
while (equalizePalette(tempPalette)) {
|
||||
_vm->_events->delay(15 * speed);
|
||||
}
|
||||
|
||||
setPalette(tempPalette);
|
||||
fillRect(Common::Rect(0, 0, this->w, this->h), 0);
|
||||
}
|
||||
|
||||
void Screen::fadeIn(const byte palette[Graphics::PALETTE_SIZE], int speed) {
|
||||
int count = 50;
|
||||
while (equalizePalette(palette) && --count) {
|
||||
_vm->_events->delay(15 * speed);
|
||||
}
|
||||
|
||||
setPalette(palette);
|
||||
}
|
||||
|
||||
void Screen::randomTransition() {
|
||||
Events &events = *_vm->_events;
|
||||
const int TRANSITION_MULTIPLIER = 0x15a4e35;
|
||||
clearDirtyRects();
|
||||
assert(IS_SERRATED_SCALPEL);
|
||||
|
||||
for (int idx = 0; idx <= 65535 && !_vm->shouldQuit(); ++idx) {
|
||||
_transitionSeed = _transitionSeed * TRANSITION_MULTIPLIER + 1;
|
||||
int offset = _transitionSeed & 0xFFFF;
|
||||
|
||||
if (offset < (this->width() * this->height()))
|
||||
*((byte *)getPixels() + offset) = *((const byte *)_backBuffer.getPixels() + offset);
|
||||
|
||||
if (idx != 0 && (idx % 300) == 0) {
|
||||
// Ensure there's a full screen dirty rect for the next frame update
|
||||
if (!isDirty())
|
||||
addDirtyRect(Common::Rect(0, 0, this->w, this->h));
|
||||
|
||||
events.pollEvents();
|
||||
events.delay(1);
|
||||
}
|
||||
}
|
||||
|
||||
// Make sure everything has been transferred
|
||||
SHblitFrom(_backBuffer);
|
||||
}
|
||||
|
||||
void Screen::verticalTransition() {
|
||||
Events &events = *_vm->_events;
|
||||
|
||||
byte table[640];
|
||||
Common::fill(&table[0], &table[640], 0);
|
||||
|
||||
for (int yp = 0; yp < this->height(); ++yp) {
|
||||
for (int xp = 0; xp < this->width(); ++xp) {
|
||||
int temp = (table[xp] >= (this->height() - 3)) ? this->height() - table[xp] :
|
||||
_vm->getRandomNumber(3) + 1;
|
||||
|
||||
if (temp) {
|
||||
SHblitFrom(_backBuffer1, Common::Point(xp, table[xp]),
|
||||
Common::Rect(xp, table[xp], xp + 1, table[xp] + temp));
|
||||
table[xp] += temp;
|
||||
}
|
||||
}
|
||||
|
||||
events.delay(10);
|
||||
}
|
||||
}
|
||||
|
||||
void Screen::restoreBackground(const Common::Rect &r) {
|
||||
if (r.width() > 0 && r.height() > 0)
|
||||
_backBuffer.SHblitFrom(_backBuffer2, Common::Point(r.left, r.top), r);
|
||||
}
|
||||
|
||||
void Screen::slamArea(int16 xp, int16 yp, int16 width_, int16 height_) {
|
||||
slamRect(Common::Rect(xp, yp, xp + width_, yp + height_));
|
||||
}
|
||||
|
||||
void Screen::slamRect(const Common::Rect &r) {
|
||||
if (r.width() && r.height() > 0) {
|
||||
Common::Rect srcRect = r, destRect = r;
|
||||
|
||||
destRect.translate(-_currentScroll.x, -_currentScroll.y);
|
||||
|
||||
if (destRect.left < 0) {
|
||||
srcRect.left += -destRect.left;
|
||||
destRect.left = 0;
|
||||
}
|
||||
if (destRect.top < 0) {
|
||||
srcRect.top += -destRect.top;
|
||||
destRect.top = 0;
|
||||
}
|
||||
if (destRect.right > SHERLOCK_SCREEN_WIDTH) {
|
||||
srcRect.right -= (destRect.left - SHERLOCK_SCREEN_WIDTH);
|
||||
destRect.right = SHERLOCK_SCREEN_WIDTH;
|
||||
}
|
||||
if (destRect.bottom > SHERLOCK_SCREEN_HEIGHT) {
|
||||
srcRect.bottom -= (destRect.bottom - SHERLOCK_SCREEN_HEIGHT);
|
||||
destRect.bottom = SHERLOCK_SCREEN_HEIGHT;
|
||||
}
|
||||
|
||||
if (srcRect.isValidRect())
|
||||
SHblitFrom(_backBuffer, Common::Point(destRect.left, destRect.top), srcRect);
|
||||
}
|
||||
}
|
||||
|
||||
void Screen::flushImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp,
|
||||
int16 *width_, int16 *height_) {
|
||||
Common::Point imgPos = pt + frame->_offset;
|
||||
Common::Rect newBounds(imgPos.x, imgPos.y, imgPos.x + frame->_frame.w, imgPos.y + frame->_frame.h);
|
||||
Common::Rect oldBounds(*xp, *yp, *xp + *width_, *yp + *height_);
|
||||
|
||||
if (!_flushScreen) {
|
||||
// See if the areas of the old and new overlap, and if so combine the areas
|
||||
if (newBounds.intersects(oldBounds)) {
|
||||
Common::Rect mergedBounds = newBounds;
|
||||
mergedBounds.extend(oldBounds);
|
||||
mergedBounds.right += 1;
|
||||
mergedBounds.bottom += 1;
|
||||
|
||||
slamRect(mergedBounds);
|
||||
} else {
|
||||
// The two areas are independent, so copy them both
|
||||
slamRect(newBounds);
|
||||
slamRect(oldBounds);
|
||||
}
|
||||
}
|
||||
|
||||
*xp = newBounds.left;
|
||||
*yp = newBounds.top;
|
||||
*width_ = newBounds.width();
|
||||
*height_ = newBounds.height();
|
||||
}
|
||||
|
||||
void Screen::flushScaleImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp,
|
||||
int16 *width_, int16 *height_, int scaleVal) {
|
||||
Common::Point imgPos(pt.x + frame->sDrawXOffset(scaleVal), pt.y + frame->sDrawYOffset(scaleVal));
|
||||
Common::Rect newBounds(imgPos.x, imgPos.y, imgPos.x + frame->sDrawXSize(scaleVal),
|
||||
imgPos.y + frame->sDrawYSize(scaleVal));
|
||||
Common::Rect oldBounds(*xp, *yp, *xp + *width_, *yp + *height_);
|
||||
|
||||
if (!_flushScreen) {
|
||||
// See if the areas of the old and new overlap, and if so combine the areas
|
||||
if (newBounds.intersects(oldBounds)) {
|
||||
Common::Rect mergedBounds = newBounds;
|
||||
mergedBounds.extend(oldBounds);
|
||||
mergedBounds.right += 1;
|
||||
mergedBounds.bottom += 1;
|
||||
|
||||
slamRect(mergedBounds);
|
||||
} else {
|
||||
// The two areas are independent, so copy them both
|
||||
slamRect(newBounds);
|
||||
slamRect(oldBounds);
|
||||
}
|
||||
}
|
||||
|
||||
*xp = newBounds.left;
|
||||
*yp = newBounds.top;
|
||||
*width_ = newBounds.width();
|
||||
*height_ = newBounds.height();
|
||||
}
|
||||
|
||||
void Screen::flushImage(ImageFrame *frame, const Common::Point &pt, Common::Rect &newBounds, int scaleVal) {
|
||||
Common::Point newPos(newBounds.left, newBounds.top);
|
||||
Common::Point newSize(newBounds.width(), newBounds.height());
|
||||
|
||||
if (scaleVal == SCALE_THRESHOLD)
|
||||
flushImage(frame, pt, &newPos.x, &newPos.y, &newSize.x, &newSize.y);
|
||||
else
|
||||
flushScaleImage(frame, pt, &newPos.x, &newPos.y, &newSize.x, &newSize.y, scaleVal);
|
||||
|
||||
// Transfer the pos and size amounts into a single bounds rect
|
||||
newBounds = Common::Rect(newPos.x, newPos.y, newPos.x + newSize.x, newPos.y + newSize.y);
|
||||
}
|
||||
|
||||
void Screen::blockMove(const Common::Rect &r) {
|
||||
Common::Rect bounds = r;
|
||||
slamRect(bounds);
|
||||
}
|
||||
|
||||
void Screen::blockMove() {
|
||||
blockMove(Common::Rect(0, 0, width(), height()));
|
||||
}
|
||||
|
||||
void Screen::print(const Common::Point &pt, uint color, const char *formatStr, ...) {
|
||||
// Create the string to display
|
||||
va_list args;
|
||||
va_start(args, formatStr);
|
||||
Common::String str = Common::String::vformat(formatStr, args);
|
||||
va_end(args);
|
||||
|
||||
// Figure out area to draw text in
|
||||
Common::Point pos = pt;
|
||||
int width_ = stringWidth(str);
|
||||
pos.y--; // Font is always drawing one line higher
|
||||
if (!pos.x)
|
||||
// Center text horizontally
|
||||
pos.x = (this->width() - width_) / 2;
|
||||
|
||||
Common::Rect textBounds(pos.x, pos.y, pos.x + width_, pos.y + fontHeight());
|
||||
if (textBounds.right > this->width())
|
||||
textBounds.moveTo(this->width() - width_, textBounds.top);
|
||||
if (textBounds.bottom > this->height())
|
||||
textBounds.moveTo(textBounds.left, this->height() - fontHeight());
|
||||
|
||||
// Write out the string at the given position
|
||||
writeString(str, Common::Point(textBounds.left, textBounds.top), color);
|
||||
|
||||
// Copy the affected area to the screen
|
||||
slamRect(textBounds);
|
||||
}
|
||||
|
||||
void Screen::gPrint(const Common::Point &pt, uint color, const char *formatStr, ...) {
|
||||
// Create the string to display
|
||||
va_list args;
|
||||
va_start(args, formatStr);
|
||||
Common::String str = Common::String::vformat(formatStr, args);
|
||||
va_end(args);
|
||||
|
||||
// Print the text
|
||||
writeString(str, pt, color);
|
||||
}
|
||||
|
||||
void Screen::writeString(const Common::String &str, const Common::Point &pt, uint overrideColor) {
|
||||
Fonts::writeString(&_backBuffer, str, pt, overrideColor);
|
||||
}
|
||||
|
||||
void Screen::vgaBar(const Common::Rect &r, int color) {
|
||||
_backBuffer.fillRect(r, color);
|
||||
slamRect(r);
|
||||
}
|
||||
|
||||
void Screen::setDisplayBounds(const Common::Rect &r) {
|
||||
_backBuffer.create(_backBuffer1, r);
|
||||
assert(_backBuffer.width() == r.width());
|
||||
assert(_backBuffer.height() == r.height());
|
||||
}
|
||||
|
||||
void Screen::resetDisplayBounds() {
|
||||
_backBuffer.create(_backBuffer1, _backBuffer1.getBounds());
|
||||
}
|
||||
|
||||
Common::Rect Screen::getDisplayBounds() {
|
||||
return _backBuffer.getBounds();
|
||||
}
|
||||
|
||||
void Screen::synchronize(Serializer &s) {
|
||||
int fontNumb = fontNumber();
|
||||
s.syncAsByte(fontNumb);
|
||||
if (s.isLoading())
|
||||
setFont(fontNumb);
|
||||
}
|
||||
|
||||
void Screen::initPaletteFade(int bytesToRead) {
|
||||
Common::copy(&_cMap[0], &_cMap[Graphics::PALETTE_SIZE], &_sMap[0]);
|
||||
Common::copy(&_cMap[0], &_cMap[Graphics::PALETTE_SIZE], &_tMap[0]);
|
||||
|
||||
// Set how many bytes need to be read / have been read
|
||||
_fadeBytesRead = 0;
|
||||
_fadeBytesToRead = bytesToRead;
|
||||
_oldFadePercent = 0;
|
||||
}
|
||||
|
||||
int Screen::fadeRead(Common::SeekableReadStream &stream, byte *buf, int totalSize) {
|
||||
warning("TODO: fadeRead");
|
||||
stream.read(buf, totalSize);
|
||||
return totalSize;
|
||||
}
|
||||
|
||||
void Screen::translatePalette(byte palette[Graphics::PALETTE_SIZE]) {
|
||||
for (int idx = 0; idx < Graphics::PALETTE_SIZE; ++idx)
|
||||
palette[idx] = PALETTE_6BIT_TO_8BIT(palette[idx]);
|
||||
}
|
||||
|
||||
} // End of namespace Sherlock
|
||||
Reference in New Issue
Block a user