Ticket #1581: restoreCharsetBg.patch

gfx.cpp

@@ -544 +544 @@
 
 void ScummEngine::restoreBG(Common::Rect rect, byte backColor) {
         VirtScreen *vs;
-        byte *backbuff;
+        byte *screenBuf;
 
         if (rect.top < 0)
                 rect.top = 0;
@@ -567 +567 @@
 
         markRectAsDirty(vs->number, rect, USAGE_BIT_RESTORED);
 
-        int offset = rect.top * vs->width + vs->xstart + rect.left;
-        backbuff = vs->screenPtr + offset;
+        const int offset = rect.top * vs->width + vs->xstart + rect.left;
+        screenBuf = vs->screenPtr + offset;
 
         int height = rect.height();
         int width = rect.width();
 
         if (vs->hasTwoBuffers && _currentRoom != 0 && isLightOn()) {
-                blit(backbuff, vs->backBuf + offset, width, height);
+                blit(screenBuf, vs->backBuf + offset, width, height);
                 if (vs->number == kMainVirtScreen && _charset->_hasMask && height) {
                         byte *mask;
 
@@ -600 +600 @@
                 }
         } else {
                 while (height--) {
-                        memset(backbuff, backColor, width);
-                        backbuff += vs->width;
+                        memset(screenBuf, backColor, width);
+                        screenBuf += vs->width;
                 }
         }
 }
 
 void CharsetRenderer::restoreCharsetBg() {
+        _nextLeft = _vm->_string[0].xpos;
+        _nextTop = _vm->_string[0].ypos;
+
         if (_hasMask) {
-                // Restore background on the whole text area. To do this, we simply
-                // pass a large rect to restoreBG, and then rely on it clipping that
-                // rect. Also, restoreBG() will use findVirtScreen(rect.top) to
-                // determine the virtual screen on which to operate. This is fine
-                // for us, since we pass in rect.top, so in older games, the text
-                // display area is used; in newer games, the main virtscreen gets
-                // restored. That's exactly what we need.
-                //
-                // Of course this will break down if one of the older games (with
-                // multiple virtual screens in use) draw text outside the text virtual
-                // screen (verbs are excluded, they are handled in a special fashion).
-                // But I have no indication that this does ever happen.
-                _vm->restoreBG(Common::Rect(5000, 5000));
                 _hasMask = false;
                 _str.left = -1;
                 _left = -1;
-        }
 
-        _nextLeft = _vm->_string[0].xpos;
-        _nextTop = _vm->_string[0].ypos;
+                // Restore background on the whole text area. This code is based on
+                // restoreBG(), but was changed to only restore those parts which are
+                // currently covered by the charset mask.
+                VirtScreen *vs = _vm->findVirtScreen(0);
+                assert(vs);
+                
+                _vm->markRectAsDirty(vs->number, Common::Rect(vs->width, vs->height), USAGE_BIT_RESTORED);
+        
+                const byte *backBuf = vs->backBuf + vs->xstart;
+                byte *screenBuf = vs->screenPtr + vs->xstart;
+        
+                if (vs->hasTwoBuffers && _vm->_currentRoom != 0 && _vm->isLightOn()) {
+                        if (vs->number == kMainVirtScreen) {
+                                // Restore from back buffer, but only those parts which are
+                                // currently covered by the charset mask. In addition, we
+                                // clean out the charset mask
+
+                                byte *mask = _vm->getMaskBuffer(0, 0, 0);
+                                const int mask_width = _vm->gdi._numStrips;
+                                assert(vs->width == 8 * _vm->gdi._numStrips);
+                                
+                                int height = vs->height;
+                                while (height--) {
+                                        for (int w = 0; w < mask_width; ++w) {
+                                                const byte maskbits = mask[w];
+                                                if (maskbits) {
+                                                        const byte *src = backBuf + w*8;
+                                                        byte *dst = screenBuf + w*8;
+                                                        if (maskbits & 0x80)
+                                                                dst[0] = src[0];
+                                                        if (maskbits & 0x40)
+                                                                dst[1] = src[1];
+                                                        if (maskbits & 0x20)
+                                                                dst[2] = src[2];
+                                                        if (maskbits & 0x10)
+                                                                dst[3] = src[3];
+                                                        if (maskbits & 0x08)
+                                                                dst[4] = src[4];
+                                                        if (maskbits & 0x04)
+                                                                dst[5] = src[5];
+                                                        if (maskbits & 0x02)
+                                                                dst[6] = src[6];
+                                                        if (maskbits & 0x01)
+                                                                dst[7] = src[7];
+
+                                                        mask[w] = 0;
+                                                }
+                                        }
+                                        screenBuf += vs->width;
+                                        backBuf += vs->width;
+                                        mask += _vm->gdi._numStrips;
+                                }
+                        } else {
+                                // Restore from back buffer
+                                _vm->blit(screenBuf, backBuf, vs->width, vs->height);
+                        }
+                } else {
+                        // Clear area
+                        memset(screenBuf, 0, vs->height * vs->width);
+                }
+        }
 }
 
 void CharsetRenderer::clearCharsetMask() {