libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-04-02 23:01:42 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

BACKENDS: ATARI: Refactor & optimize dirty rects

Browse Source 
This was long overdue. From my observation dirty rects don't need much
care, usually game engines already prepare them in a good shape (no
overlapping).

Also the overhead of calling the rect version of C2P isn't as big as I
was fearing, 256 64x64 rectangles are blitted roughly as quickly
as blitting one 1 MB block.

Removal of the rects traversal significantly speeds up Eco Quest for
instance.
This commit is contained in:
Miro Kropacek 2023-04-08 20:25:14 +02:00
parent 740aefcedf
commit 1870433daf
3 changed files with 158 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
backends/graphics/atari/atari-graphics-supervidel.h
View File

@ -70,7 +70,7 @@ public:
return graphicsModes;
}
protected:
private:
AtariMemAlloc getStRamAllocFunc() const override {
return [](size_t bytes) {
uintptr ptr = Mxalloc(bytes, MX_STRAM);
@ -85,7 +85,6 @@ protected:
return [](void *ptr) { Mfree((uintptr)ptr & 0x00FFFFFF); };
}
private:
static long hasSvRamBoosted() {
register long ret __asm__ ("d0") = 0;

230
backends/graphics/atari/atari-graphics.cpp
View File

@ -24,7 +24,6 @@
#include <mint/cookie.h>
#include <mint/falcon.h>
#include <mint/osbind.h>
#include <utility>
#include "backends/graphics/atari/atari-graphics-asm.h"
#include "backends/graphics/atari/atari-graphics-superblitter.h"
@ -176,26 +175,16 @@ OSystem::TransactionError AtariGraphicsManager::endGFXTransaction() {
_chunkySurface.init(_pendingState.width, _pendingState.height, _pendingState.width,
_chunkySurface.getPixels(), _pendingState.format);
_buffer[FRONT_BUFFER]->reset();
_buffer[BACK_BUFFER1]->reset();
_buffer[BACK_BUFFER2]->reset();
_screen[FRONT_BUFFER]->reset(_pendingState.width, _pendingState.height);
_screen[BACK_BUFFER1]->reset(_pendingState.width, _pendingState.height);
_screen[BACK_BUFFER2]->reset(_pendingState.width, _pendingState.height);
_workScreen = _buffer[_pendingState.mode <= GraphicsMode::SingleBuffering ? FRONT_BUFFER : BACK_BUFFER1];
_screenSurface.init(_pendingState.width, _pendingState.height, _pendingState.width,
_workScreen->p, _screenSurface.format);
_workScreen = _screen[_pendingState.mode <= GraphicsMode::SingleBuffering ? FRONT_BUFFER : BACK_BUFFER1];
// in case of resolution change from GUI
if (_oldWorkScreen)
_oldWorkScreen = _workScreen;
// some games do not initialize their viewport entirely
if (_pendingState.mode != GraphicsMode::DirectRendering) {
memset(_chunkySurface.getPixels(), 0, _chunkySurface.h * _chunkySurface.pitch);
addDirtyRect(_chunkySurface, _workScreen->dirtyRects, Common::Rect(_chunkySurface.w, _chunkySurface.h));
} else {
memset(_screenSurface.getPixels(), 0, _screenSurface.h * _screenSurface.pitch);
}
memset(_palette, 0, sizeof(_palette));
_pendingScreenChange = kPendingScreenChangeScreen | kPendingScreenChangePalette;
@ -231,12 +220,11 @@ void AtariGraphicsManager::copyRectToScreen(const void *buf, int pitch, int x, i
if (_currentState.mode != GraphicsMode::DirectRendering) {
_chunkySurface.copyRectToSurface(buf, pitch, x, y, w, h);
addDirtyRect(_chunkySurface, _workScreen->dirtyRects, Common::Rect(x, y, x + w, y + h));
_workScreen->addDirtyRect(Common::Rect(x, y, x + w, y + h));
} else {
// TODO: c2p with 16pix align
_screenSurface.copyRectToSurface(buf, pitch, x, y, w, h);
_dirtyScreenRect = Common::Rect(x, y, x + w, y + h);
_workScreen->surf.copyRectToSurface(buf, pitch, x, y, w, h);
_workScreen->addDirtyRect(Common::Rect(x, y, x + w, y + h));
updateScreen();
}
@ -245,17 +233,16 @@ void AtariGraphicsManager::copyRectToScreen(const void *buf, int pitch, int x, i
Graphics::Surface *AtariGraphicsManager::lockScreen() {
//debug("lockScreen");
return _currentState.mode != GraphicsMode::DirectRendering ? &_chunkySurface : &_screenSurface;
return _currentState.mode != GraphicsMode::DirectRendering ? &_chunkySurface : &_workScreen->surf;
}
void AtariGraphicsManager::unlockScreen() {
if (_currentState.mode != GraphicsMode::DirectRendering) {
addDirtyRect(_chunkySurface, _workScreen->dirtyRects, Common::Rect(_chunkySurface.w, _chunkySurface.h));
} else {
_dirtyScreenRect = Common::Rect(_screenSurface.w, _screenSurface.h);
//debug("unlockScreen: %d x %d", _workScreen->surf.w, _workScreen->surf.h);
_workScreen->addDirtyRect(Common::Rect(_workScreen->surf.w, _workScreen->surf.h));
if (_currentState.mode == GraphicsMode::DirectRendering)
updateScreen();
}
}
void AtariGraphicsManager::fillScreen(uint32 col) {
@ -285,8 +272,7 @@ void AtariGraphicsManager::updateScreen() {
}
// updates outOfScreen OR srcRect/dstRect (only if visible/needed)
_cursor.update(isOverlayVisible() ? _screenOverlaySurface : _screenSurface,
_workScreen->cursorPositionChanged || _workScreen->cursorSurfaceChanged);
_cursor.update(_workScreen->surf, _workScreen->cursorPositionChanged || _workScreen->cursorSurfaceChanged);
bool screenUpdated;
@ -295,50 +281,58 @@ void AtariGraphicsManager::updateScreen() {
assert(_currentState.mode >= GraphicsMode::DirectRendering && _currentState.mode <= GraphicsMode::TripleBuffering);
if (isOverlayVisible()) {
screenUpdated = updateBuffered(_overlaySurface, _screenOverlaySurface, _workScreen->dirtyRects);
assert(_workScreen == _buffer[OVERLAY_BUFFER]);
screenUpdated = updateBuffered(_overlaySurface, _workScreen->dirtyRects);
assert(_workScreen == _screen[OVERLAY_BUFFER]);
_workScreen->dirtyRects.clear();
_workScreen->clearDirtyRects();
unlockSuperBlitter();
} else if (_currentState.mode == GraphicsMode::DirectRendering) {
screenUpdated = updateDirect();
assert(_workScreen == _buffer[FRONT_BUFFER]);
assert(_workScreen == _screen[FRONT_BUFFER]);
_workScreen->clearDirtyRects();
unlockSuperBlitter();
} else if (_currentState.mode == GraphicsMode::SingleBuffering) {
screenUpdated = updateBuffered(_chunkySurface, _screenSurface, _workScreen->dirtyRects);
assert(_workScreen == _buffer[FRONT_BUFFER]);
screenUpdated = updateBuffered(_chunkySurface, _workScreen->dirtyRects);
assert(_workScreen == _screen[FRONT_BUFFER]);
_workScreen->dirtyRects.clear();
_workScreen->clearDirtyRects();
unlockSuperBlitter();
} else {
screenUpdated = updateBuffered(_chunkySurface, _screenSurface, _workScreen->dirtyRects);
assert(_workScreen == _buffer[BACK_BUFFER1]);
assert(_workScreen == _screen[BACK_BUFFER1]);
// apply dirty rects from previous frame
if (!_buffer[BACK_BUFFER2]->dirtyRects.empty()) {
screenUpdated |= updateBuffered(_chunkySurface, _screenSurface, _buffer[BACK_BUFFER2]->dirtyRects);
// clear the least recent dirty rects
_buffer[BACK_BUFFER2]->dirtyRects.clear();
if (_workScreen->fullRedrawPending) {
// scheduled fullscreen redraw in this frame...
screenUpdated = updateBuffered(_chunkySurface, _workScreen->dirtyRects);
} else if (_screen[BACK_BUFFER2]->fullRedrawPending) {
// scheduled fullscreen redraw in previous frame...
screenUpdated = updateBuffered(_chunkySurface, _screen[BACK_BUFFER2]->dirtyRects);
} else {
screenUpdated = updateBuffered(_chunkySurface, _workScreen->dirtyRects);
// apply dirty rects from previous frame
if (!_screen[BACK_BUFFER2]->dirtyRects.empty())
screenUpdated |= updateBuffered(_chunkySurface, _screen[BACK_BUFFER2]->dirtyRects);
}
// clear the least recent dirty rects
_screen[BACK_BUFFER2]->clearDirtyRects();
// render into BACK_BUFFER1 and/or BACK_BUFFER2 and set the most recent one
if (screenUpdated) {
_buffer[FRONT_BUFFER] = _buffer[BACK_BUFFER1];
_screen[FRONT_BUFFER] = _screen[BACK_BUFFER1];
ScreenInfo *tmp = _buffer[BACK_BUFFER1];
_buffer[BACK_BUFFER1] = _buffer[BACK_BUFFER2];
_buffer[BACK_BUFFER2] = tmp;
Screen *tmp = _screen[BACK_BUFFER1];
_screen[BACK_BUFFER1] = _screen[BACK_BUFFER2];
_screen[BACK_BUFFER2] = tmp;
}
// finish blitting before setting new screen address
unlockSuperBlitter();
#ifdef SCREEN_ACTIVE
asm_screen_set_vram(_buffer[FRONT_BUFFER]->p);
asm_screen_set_vram(_screen[FRONT_BUFFER]->surf.getPixels());
#endif
_workScreen = _buffer[BACK_BUFFER1];
_screenSurface.setPixels(_workScreen->p);
_workScreen = _screen[BACK_BUFFER1];
}
#ifdef SCREEN_ACTIVE
@ -350,14 +344,14 @@ void AtariGraphicsManager::updateScreen() {
else
asm_screen_set_scp_res(scp_640x480x8_rgb);
asm_screen_set_vram(_screenOverlaySurface.getPixels());
asm_screen_set_vram(_screen[OVERLAY_BUFFER]->surf.getPixels());
asm_screen_set_falcon_palette(_overlayPalette);
resolutionChanged = true;
}
if (_pendingScreenChange & kPendingScreenChangeScreen) {
setVidelResolution();
asm_screen_set_vram(_buffer[FRONT_BUFFER]->p);
asm_screen_set_vram(_screen[FRONT_BUFFER]->surf.getPixels());
resolutionChanged = true;
}
@ -400,7 +394,7 @@ void AtariGraphicsManager::showOverlay(bool inGUI) {
_cursor.swap();
_oldWorkScreen = _workScreen;
_workScreen = _buffer[OVERLAY_BUFFER];
_workScreen = _screen[OVERLAY_BUFFER];
_overlayVisible = true;
}
@ -415,7 +409,7 @@ void AtariGraphicsManager::hideOverlay() {
_pendingScreenChange |= (kPendingScreenChangeScreen | kPendingScreenChangePalette);
// do not cache dirtyRects and oldCursorRect
_workScreen->reset();
_workScreen->reset(getOverlayWidth(), getOverlayHeight());
_workScreen = _oldWorkScreen;
_oldWorkScreen = nullptr;
@ -433,7 +427,8 @@ void AtariGraphicsManager::clearOverlay() {
if (!_overlayVisible)
return;
const Graphics::Surface &sourceSurface = _currentState.mode == GraphicsMode::DirectRendering ? _screenSurface : _chunkySurface;
const Graphics::Surface &sourceSurface =
_currentState.mode == GraphicsMode::DirectRendering ? _screen[FRONT_BUFFER]->surf : _chunkySurface;
int w = sourceSurface.w;
int h = sourceSurface.h;
@ -487,7 +482,7 @@ void AtariGraphicsManager::clearOverlay() {
memset(_overlaySurface.getBasePtr(0, _overlaySurface.h - vOffset), 0, _overlaySurface.pitch * vOffset);
addDirtyRect(_overlaySurface, _buffer[OVERLAY_BUFFER]->dirtyRects, Common::Rect(_overlaySurface.w, _overlaySurface.h));
_screen[OVERLAY_BUFFER]->addDirtyRect(Common::Rect(_screen[OVERLAY_BUFFER]->surf.w, _screen[OVERLAY_BUFFER]->surf.h));
}
void AtariGraphicsManager::grabOverlay(Graphics::Surface &surface) const {
@ -500,8 +495,7 @@ void AtariGraphicsManager::copyRectToOverlay(const void *buf, int pitch, int x,
//debug("copyRectToOverlay: %d, %d, %d, %d, %d", pitch, x, y, w, h);
_overlaySurface.copyRectToSurface(buf, pitch, x, y, w, h);
addDirtyRect(_overlaySurface, _buffer[OVERLAY_BUFFER]->dirtyRects, Common::Rect(x, y, x + w, y + h));
_screen[OVERLAY_BUFFER]->addDirtyRect(Common::Rect(x, y, x + w, y + h));
}
bool AtariGraphicsManager::showMouse(bool visible) {
@ -543,7 +537,7 @@ void AtariGraphicsManager::setCursorPalette(const byte *colors, uint start, uint
}
void AtariGraphicsManager::updateMousePosition(int deltaX, int deltaY) {
_cursor.updatePosition(deltaX, deltaY, isOverlayVisible() ? _screenOverlaySurface : _screenSurface);
_cursor.updatePosition(deltaX, deltaY, _workScreen->surf);
cursorPositionChanged();
}
@ -577,26 +571,19 @@ Common::Keymap *AtariGraphicsManager::getKeymap() const {
void AtariGraphicsManager::allocateSurfaces() {
for (int i : { FRONT_BUFFER, BACK_BUFFER1, BACK_BUFFER2 }) {
allocateAtariSurface(_screenSurface, SCREEN_WIDTH, SCREEN_HEIGHT, PIXELFORMAT_CLUT8, getStRamAllocFunc());
_buffer[i] = new ScreenInfo((byte *)_screenSurface.getPixels());
_screen[i] = new Screen(this, SCREEN_WIDTH, SCREEN_HEIGHT, PIXELFORMAT_CLUT8);
}
_screen[OVERLAY_BUFFER] = new Screen(this, getOverlayWidth(), getOverlayHeight(), getOverlayFormat());
_chunkySurface.create(SCREEN_WIDTH, SCREEN_HEIGHT, PIXELFORMAT_CLUT8);
allocateAtariSurface(_screenOverlaySurface, getOverlayWidth(), getOverlayHeight(), getOverlayFormat(), getStRamAllocFunc());
_buffer[OVERLAY_BUFFER] = new ScreenInfo((byte *)_screenOverlaySurface.getPixels());
_overlaySurface.create(getOverlayWidth(), getOverlayHeight(), getOverlayFormat());
}
void AtariGraphicsManager::freeSurfaces() {
for (int i : { FRONT_BUFFER, BACK_BUFFER1, BACK_BUFFER2, OVERLAY_BUFFER }) {
freeAtariSurface(_buffer[i]->p, getStRamFreeFunc());
delete _buffer[i];
_buffer[i] = nullptr;
delete _screen[i];
_screen[i] = nullptr;
}
_screenSurface = Graphics::Surface();
_screenOverlaySurface = Graphics::Surface();
_workScreen = nullptr;
_chunkySurface.free();
@ -607,29 +594,29 @@ void AtariGraphicsManager::setVidelResolution() const {
if (_vgaMonitor) {
// TODO: aspect ratio correction
// TODO: supervidel 320x240...
if (_screenSurface.w == 320) {
if (_screenSurface.h == 200)
if (_workScreen->surf.w == 320) {
if (_workScreen->surf.h == 200)
asm_screen_set_scp_res(scp_320x200x8_vga);
else
asm_screen_set_scp_res(scp_320x240x8_vga);
} else {
if (_screenSurface.h == 400)
if (_workScreen->surf.h == 400)
asm_screen_set_scp_res(scp_640x400x8_vga);
else
asm_screen_set_scp_res(scp_640x480x8_vga);
}
} else {
if (_screenSurface.w == 320) {
if (_screenSurface.h == 240)
if (_workScreen->surf.w == 320) {
if (_workScreen->surf.h == 240)
asm_screen_set_scp_res(scp_320x240x8_rgb);
else if (_screenSurface.h == 200 && _aspectRatioCorrection)
else if (_workScreen->surf.h == 200 && _aspectRatioCorrection)
asm_screen_set_scp_res(scp_320x200x8_rgb60);
else
asm_screen_set_scp_res(scp_320x200x8_rgb);
} else {
if (_screenSurface.h == 480)
if (_workScreen->surf.h == 480)
asm_screen_set_scp_res(scp_640x480x8_rgb);
else if (_screenSurface.h == 400 && _aspectRatioCorrection)
else if (_workScreen->surf.h == 400 && _aspectRatioCorrection)
asm_screen_set_scp_res(scp_640x400x8_rgb60);
else
asm_screen_set_scp_res(scp_640x400x8_rgb);
@ -638,6 +625,7 @@ void AtariGraphicsManager::setVidelResolution() const {
}
bool AtariGraphicsManager::updateDirect() {
const Common::Rect &dirtyScreenRect = _workScreen->dirtyRects.empty() ? Common::Rect() : _workScreen->dirtyRects.front();
bool &cursorPositionChanged = _workScreen->cursorPositionChanged;
bool &cursorSurfaceChanged = _workScreen->cursorSurfaceChanged;
Common::Rect &oldCursorRect = _workScreen->oldCursorRect;
@ -649,16 +637,16 @@ bool AtariGraphicsManager::updateDirect() {
bool drawCursor = cursorPositionChanged || cursorSurfaceChanged;
if (!drawCursor && _cursor.visible && !_dirtyScreenRect.isEmpty())
drawCursor = _dirtyScreenRect.intersects(_cursor.dstRect);
if (!drawCursor && _cursor.visible && !dirtyScreenRect.isEmpty())
drawCursor = dirtyScreenRect.intersects(_cursor.dstRect);
static Graphics::Surface cachedCursorSurface;
if (!oldCursorRect.isEmpty() && !_dirtyScreenRect.isEmpty()) {
const Common::Rect intersectingRect = _dirtyScreenRect.findIntersectingRect(oldCursorRect);
if (!oldCursorRect.isEmpty() && !dirtyScreenRect.isEmpty()) {
const Common::Rect intersectingRect = dirtyScreenRect.findIntersectingRect(oldCursorRect);
if (!intersectingRect.isEmpty()) {
// update cached surface
const Graphics::Surface intersectingScreenSurface = _screenSurface.getSubArea(intersectingRect);
const Graphics::Surface intersectingScreenSurface = _workScreen->surf.getSubArea(intersectingRect);
cachedCursorSurface.copyRectToSurface(
intersectingScreenSurface,
intersectingRect.left - oldCursorRect.left,
@ -667,10 +655,8 @@ bool AtariGraphicsManager::updateDirect() {
}
}
_dirtyScreenRect = Common::Rect();
if ((cursorPositionChanged || !_cursor.visible) && !oldCursorRect.isEmpty()) {
_screenSurface.copyRectToSurface(
_workScreen->surf.copyRectToSurface(
cachedCursorSurface,
oldCursorRect.left, oldCursorRect.top,
Common::Rect(oldCursorRect.width(), oldCursorRect.height()));
@ -687,11 +673,11 @@ bool AtariGraphicsManager::updateDirect() {
cachedCursorSurface.create(_cursor.dstRect.width(), _cursor.dstRect.height(), _cursor.surface.format);
}
// background has been restored, so it's safe to read _screenSurface
// background has been restored, so it's safe to read _workScreen
if (oldCursorRect.isEmpty())
cachedCursorSurface.copyRectToSurface(_screenSurface, 0, 0, _cursor.dstRect);
cachedCursorSurface.copyRectToSurface(_workScreen->surf, 0, 0, _cursor.dstRect);
_screenSurface.copyRectToSurfaceWithKey(
_workScreen->surf.copyRectToSurfaceWithKey(
_cursor.surface,
_cursor.dstRect.left, _cursor.dstRect.top,
_cursor.srcRect,
@ -706,12 +692,14 @@ bool AtariGraphicsManager::updateDirect() {
return updated;
}
bool AtariGraphicsManager::updateBuffered(const Graphics::Surface &srcSurface, Graphics::Surface &dstSurface, const DirtyRects &dirtyRects) {
// workscreen related setting; these are used even if called repeatedly
// for triple buffering
bool &cursorPositionChanged = _workScreen->cursorPositionChanged;
bool &cursorSurfaceChanged = _workScreen->cursorSurfaceChanged;
Common::Rect &oldCursorRect = _workScreen->oldCursorRect;
bool AtariGraphicsManager::updateBuffered(const Graphics::Surface &srcSurface, const DirtyRects &dirtyRects) {
//debug("updateBuffered: %d", dirtyRects.size());
// workscreen related setting; these are used even if called repeatedly for triple buffering
Graphics::Surface &dstSurface = _workScreen->surf;
bool &cursorPositionChanged = _workScreen->cursorPositionChanged;
bool &cursorSurfaceChanged = _workScreen->cursorSurfaceChanged;
Common::Rect &oldCursorRect = _workScreen->oldCursorRect;
bool updated = false;
bool drawCursor = cursorPositionChanged || cursorSurfaceChanged;;
@ -756,52 +744,50 @@ bool AtariGraphicsManager::updateBuffered(const Graphics::Surface &srcSurface, G
return updated;
}
void AtariGraphicsManager::allocateAtariSurface(Graphics::Surface &surface,
int width, int height, const Graphics::PixelFormat &format,
const AtariMemAlloc &allocFunc) {
constexpr size_t ALIGN = 16; // 16 bytes
AtariGraphicsManager::Screen::Screen(AtariGraphicsManager *manager, int width, int height, const Graphics::PixelFormat &format)
: _manager(manager) {
const AtariMemAlloc &allocFunc = _manager->getStRamAllocFunc();
surface.init(width, height, (width * format.bytesPerPixel + ALIGN - 1) & (-ALIGN), nullptr, format);
surf.init(width, height, (width * format.bytesPerPixel + ALIGN - 1) & (-ALIGN), nullptr, format);
void *pixelsUnaligned = allocFunc(sizeof(uintptr) + (surface.h * surface.pitch) + ALIGN - 1);
void *pixelsUnaligned = allocFunc(sizeof(uintptr) + (surf.h * surf.pitch) + ALIGN - 1);
if (!pixelsUnaligned) {
error("Failed to allocate memory in ST RAM");
}
surface.setPixels((void *)(((uintptr)pixelsUnaligned + sizeof(uintptr) + ALIGN - 1) & (-ALIGN)));
surf.setPixels((void *)(((uintptr)pixelsUnaligned + sizeof(uintptr) + ALIGN - 1) & (-ALIGN)));
// store the unaligned pointer for later free()
*((uintptr *)surface.getPixels() - 1) = (uintptr)pixelsUnaligned;
// store the unaligned pointer for later release
*((uintptr *)surf.getPixels() - 1) = (uintptr)pixelsUnaligned;
memset(surface.getPixels(), 0, surface.h * surface.pitch);
memset(surf.getPixels(), 0, surf.h * surf.pitch);
}
void AtariGraphicsManager::freeAtariSurface(byte *ptr, const AtariMemFree &freeFunc) {
freeFunc((void *)*((uintptr *)ptr - 1));
AtariGraphicsManager::Screen::~Screen() {
const AtariMemFree &freeFunc = _manager->getStRamFreeFunc();
freeFunc((void *)*((uintptr *)surf.getPixels() - 1));
}
void AtariGraphicsManager::addDirtyRect(const Graphics::Surface &surface,
DirtyRects &rects, Common::Rect rect) const {
alignRect(surface, rect);
void AtariGraphicsManager::Screen::addDirtyRect(Common::Rect rect) {
if (_fullRedraw)
return;
if (rect.width() == surface.w && rect.height() == surface.h) {
//debug("addDirtyRect: purge");
_manager->alignRect(surf, rect);
rects.clear();
rects.push_back(rect);
// TODO: this assumes that screen resolution == chunky buffer resolution
if ((rect.width() == surf.w && rect.height() == surf.h)
|| dirtyRects.size() == dirtyRects.capacity()) {
//debug("addDirtyRect[%d]: purge %d x %d", (int)dirtyRects.size(), surf.w, surf.h);
dirtyRects.clear();
dirtyRects.push_back(Common::Rect(surf.w, surf.h));
_fullRedraw = true;
return;
}
for (const Common::Rect &r : rects) {
if (r.contains(rect)) {
return;
}
}
// TODO: what is r.rect contains some rect from rects => delete that rect instead
// (it is costly in Common::Array...)
rects.push_back(rect);
dirtyRects.push_back(rect);
}
void AtariGraphicsManager::Cursor::update(const Graphics::Surface &screen, bool isModified) {

89
backends/graphics/atari/atari-graphics.h
View File

@ -93,14 +93,6 @@ protected:
typedef void* (*AtariMemAlloc)(size_t bytes);
typedef void (*AtariMemFree)(void *ptr);
virtual AtariMemAlloc getStRamAllocFunc() const {
return [](size_t bytes) { return (void*)Mxalloc(bytes, MX_STRAM); };
}
virtual AtariMemFree getStRamFreeFunc() const {
return [](void *ptr) { Mfree(ptr); };
}
void allocateSurfaces();
void freeSurfaces();
@ -131,6 +123,13 @@ private:
SCREEN_HEIGHT = 480
};
virtual AtariMemAlloc getStRamAllocFunc() const {
return [](size_t bytes) { return (void*)Mxalloc(bytes, MX_STRAM); };
}
virtual AtariMemFree getStRamFreeFunc() const {
return [](void *ptr) { Mfree(ptr); };
}
// use std::vector as its clear() doesn't reset capacity
using DirtyRects = std::vector<Common::Rect>;
@ -141,13 +140,7 @@ private:
void setVidelResolution() const;
bool updateDirect();
bool updateBuffered(const Graphics::Surface &srcSurface, Graphics::Surface &dstSurface, const DirtyRects &dirtyRects);
void allocateAtariSurface(Graphics::Surface &surface,
int width, int height, const Graphics::PixelFormat &format,
const AtariMemAlloc &allocFunc);
void freeAtariSurface(byte *ptr, const AtariMemFree &freeFunc);
bool updateBuffered(const Graphics::Surface &srcSurface, const DirtyRects &dirtyRects);
virtual void copyRectToSurface(Graphics::Surface &dstSurface,
const Graphics::Surface &srcSurface, int destX, int destY,
@ -161,26 +154,24 @@ private:
}
virtual void alignRect(const Graphics::Surface &srcSurface, Common::Rect &rect) const {}
void addDirtyRect(const Graphics::Surface &surface, DirtyRects &rects, Common::Rect rect) const;
void cursorPositionChanged() {
if (_overlayVisible) {
_buffer[OVERLAY_BUFFER]->cursorPositionChanged = true;
_screen[OVERLAY_BUFFER]->cursorPositionChanged = true;
} else {
_buffer[FRONT_BUFFER]->cursorPositionChanged
= _buffer[BACK_BUFFER1]->cursorPositionChanged
= _buffer[BACK_BUFFER2]->cursorPositionChanged
_screen[FRONT_BUFFER]->cursorPositionChanged
= _screen[BACK_BUFFER1]->cursorPositionChanged
= _screen[BACK_BUFFER2]->cursorPositionChanged
= true;
}
}
void cursorSurfaceChanged() {
if (_overlayVisible) {
_buffer[OVERLAY_BUFFER]->cursorSurfaceChanged = true;
_screen[OVERLAY_BUFFER]->cursorSurfaceChanged = true;
} else {
_buffer[FRONT_BUFFER]->cursorSurfaceChanged
= _buffer[BACK_BUFFER1]->cursorSurfaceChanged
= _buffer[BACK_BUFFER2]->cursorSurfaceChanged
_screen[FRONT_BUFFER]->cursorSurfaceChanged
= _screen[BACK_BUFFER1]->cursorSurfaceChanged
= _screen[BACK_BUFFER2]->cursorSurfaceChanged
= true;
}
}
@ -207,33 +198,51 @@ private:
BUFFER_COUNT
};
struct ScreenInfo {
ScreenInfo(byte *p_)
: p(p_) {
}
struct Screen {
Screen(AtariGraphicsManager *manager, int width, int height, const Graphics::PixelFormat &format);
~Screen();
void reset() {
void reset(int width, int height) {
cursorPositionChanged = true;
cursorSurfaceChanged = false;
dirtyRects.clear();
clearDirtyRects();
oldCursorRect = Common::Rect();
// erase old screen
surf.fillRect(Common::Rect(surf.w, surf.h), 0);
// set new dimensions
surf.pitch = width;
surf.w = width;
surf.h = height;
}
byte *p;
void addDirtyRect(Common::Rect rect);
void clearDirtyRects() {
dirtyRects.clear();
_fullRedraw = false;
}
const bool &fullRedrawPending = _fullRedraw;
Graphics::Surface surf;
bool cursorPositionChanged = true;
bool cursorSurfaceChanged = false;
DirtyRects dirtyRects = DirtyRects(100); // reserve 100 rects
DirtyRects dirtyRects = DirtyRects(512); // reserve 512 rects
Common::Rect oldCursorRect;
};
ScreenInfo *_buffer[BUFFER_COUNT] = {};
ScreenInfo *_workScreen = nullptr;
ScreenInfo *_oldWorkScreen = nullptr; // used in hideOverlay()
Graphics::Surface _screenSurface;
Common::Rect _dirtyScreenRect; // direct rendering only
private:
static constexpr size_t ALIGN = 16; // 16 bytes
bool _fullRedraw = false;
AtariGraphicsManager *_manager;
};
Screen *_screen[BUFFER_COUNT] = {};
Screen *_workScreen = nullptr;
Screen *_oldWorkScreen = nullptr; // used in hideOverlay()
Graphics::Surface _chunkySurface;
Graphics::Surface _screenOverlaySurface;
bool _overlayVisible = false;
Graphics::Surface _overlaySurface;