Ticket #8353: mouse.v1.diff

backends/sdl/graphics.cpp

@@ -41 +41 @@
         {0, 0, 0}
 };
 
+// Table of relative scalers magnitudes
+// [definedScale-1][_scaleFactor-1]
+static ScalerProc *scalersMagn[3][3] = {
+        { Normal1x, Normal2x, Normal3x },
+        { Normal1x, Normal1x, Normal1o5x },
+        { Normal1x, Normal1x, Normal1x }
+};
+
 const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
         return s_supportedGraphicsModes;
 }
@@ -327 +335 @@
                 _forceFull = true;
         }
 
-        // Make sure the mouse is drawn, if it should be drawn.
-        draw_mouse();
-        
         // Check whether the palette was changed in the meantime and update the
         // screen surface accordingly. 
         if (_paletteDirtyEnd != 0) {
@@ -362 +367 @@
         }
 #endif
 
+        undraw_mouse();
+
         // Force a full redraw if requested
         if (_forceFull) {
                 _num_dirty_rects = 1;
@@ -457 +464 @@
                 }
 #endif
 
+                draw_mouse();
+
                 // Finally, blit all our changes to the screen
                 SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
+        } else {
+                draw_mouse();
+                if (_num_dirty_rects)
+                        SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
         }
 
         _num_dirty_rects = 0;
@@ -480 +493 @@
                 assert(_hwscreen != 0);
                 _full_screen ^= true;
 
-                undraw_mouse();
-        
 #if defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)
                 // On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse,
                 // before SDL 1.2.6 it always returned -1 (which would indicate a
@@ -544 +555 @@
                 add_dirty_rect(x, y, w, h);
         }
 
-        /* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
-        undraw_mouse();
-
         // Try to lock the screen surface
         if (SDL_LockSurface(_screen) == -1)
                 error("SDL_LockSurface failed: %s", SDL_GetError());
@@ -568 +576 @@
 }
 
 
-void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
+void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h, bool mouseRect) {
         if (_forceFull)
                 return;
 
+        if (mouseRect) {
+                SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++];
+                r->x = x;
+                r->y = y;
+                r->w = w;
+                r->h = h;
+                return;
+        }
+
         if (_num_dirty_rects == NUM_DIRTY_RECT)
                 _forceFull = true;
         else {
@@ -718 +735 @@
 
         if (start + num > _paletteDirtyEnd)
                 _paletteDirtyEnd = start + num;
+
+        // Some games blink cursors with palette
+        if (!_overlayVisible)
+                blit_cursor();
 }
 
 void OSystem_SDL::set_shake_pos(int shake_pos) {
@@ -730 +751 @@
 #pragma mark -
 
 void OSystem_SDL::showOverlay() {
-        // hide the mouse
-        undraw_mouse();
-
         _overlayVisible = true;
         clearOverlay();
 }
 
 void OSystem_SDL::hideOverlay() {
-        // hide the mouse
-        undraw_mouse();
-
         _overlayVisible = false;
         _forceFull = true;
 }
@@ -751 +766 @@
         
         Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
         
-        // hide the mouse
-        undraw_mouse();
-
         // Clear the overlay by making the game screen "look through" everywhere.
         SDL_Rect src, dst;
         src.x = src.y = 0;
@@ -773 +785 @@
         if (_tmpscreen == NULL)
                 return;
 
-        // hide the mouse
-        undraw_mouse();
-
         if (SDL_LockSurface(_tmpscreen) == -1)
                 error("SDL_LockSurface failed: %s", SDL_GetError());
 
@@ -824 +833 @@
         cksum_valid = false;
         add_dirty_rect(x, y, w, h);
 
-        /* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
-        undraw_mouse();
-
         if (SDL_LockSurface(_tmpscreen) == -1)
                 error("SDL_LockSurface failed: %s", SDL_GetError());
 
@@ -860 +866 @@
         bool last = _mouseVisible;
         _mouseVisible = visible;
 
-        if (visible)
-                draw_mouse();
-        else
-                undraw_mouse();
+        updateScreen();
 
         return last;
 }
 
 void OSystem_SDL::set_mouse_pos(int x, int y) {
         if (x != _mouseCurState.x || y != _mouseCurState.y) {
-                undraw_mouse();
                 _mouseCurState.x = x;
                 _mouseCurState.y = y;
                 updateScreen();
@@ -892 +894 @@
         }
 }
         
-void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor) {
-
-        undraw_mouse();
-
-        assert(w <= MAX_MOUSE_W);
-        assert(h <= MAX_MOUSE_H);
-        _mouseCurState.w = w;
-        _mouseCurState.h = h;
+void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorScale) {
+        byte *tmpPtr, *dstPtr;
+        const byte *srcPtr = buf;
+        int dstPitch;
 
         _mouseHotspotX = hotspot_x;
         _mouseHotspotY = hotspot_y;
 
         _mouseKeycolor = keycolor;
 
-        if (_mouseData)
-                free(_mouseData);
+        _cursorScale = cursorScale;
 
-        _mouseData = (byte *)malloc(w * h);
-        memcpy(_mouseData, buf, w * h);
-}
+        if (_mouseCurState.w != (int)w * cursorScale || _mouseCurState.h != (int)h * cursorScale) {
+                _mouseCurState.w = w * cursorScale;
+                _mouseCurState.h = h * cursorScale;
+
+                if (_mouseSurface)
+                        SDL_FreeSurface(_mouseSurface); 
+
+                _mouseSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+                                                _mouseCurState.w,
+                                                _mouseCurState.h,
+                                                16,
+                                                _hwscreen->format->Rmask,
+                                                _hwscreen->format->Gmask,
+                                                _hwscreen->format->Bmask,
+                                                _hwscreen->format->Amask);
 
-void OSystem_SDL::toggleMouseGrab() {
-        if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
-                SDL_WM_GrabInput(SDL_GRAB_ON);
-        else
-                SDL_WM_GrabInput(SDL_GRAB_OFF);
-}
+                if (_mouseSurface == NULL)
+                        error("allocating _mouseSurface failed");
+                SDL_SetColorKey(_mouseSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
+        }
 
-void OSystem_SDL::draw_mouse() {
-        if (_mouseDrawn || !_mouseVisible)
-                return;
+        if (_mouseData)
+                free(_mouseData);
 
-        int x = _mouseCurState.x - _mouseHotspotX;
-        int y = _mouseCurState.y - _mouseHotspotY;
-        int w = _mouseCurState.w;
-        int h = _mouseCurState.h;
-        byte color;
-        const byte *src = _mouseData;           // Image representing the mouse
+        dstPtr = _mouseData = (byte *)malloc(w * h * cursorScale * cursorScale);
 
-        // clip the mouse rect, and addjust the src pointer accordingly
-        if (x < 0) {
-                w += x;
-                src -= x;
-                x = 0;
+        if (cursorScale == 1) {
+                memcpy(_mouseData, buf, w * h);
+                blit_cursor();
+                return;
         }
-        if (y < 0) {
-                h += y;
-                src -= y * _mouseCurState.w;
-                y = 0;
+
+        dstPitch = w * cursorScale;
+        for (uint i = 0; i < h; i++) {
+                for (uint j = 0; j < w; j++) {
+                        for (int k = 0; k < cursorScale; k++) {
+                                tmpPtr = dstPtr + dstPitch * k;
+                                for (int l = 0; l < cursorScale; l++) {
+                                        *tmpPtr++ = *srcPtr;
+                                }
+                        }
+                        srcPtr++;
+                        dstPtr += cursorScale;
+                }
+                dstPtr += dstPitch * (cursorScale - 1);
         }
 
-        if (w > _screenWidth - x)
-                w = _screenWidth - x;
-        if (h > _screenHeight - y)
-                h = _screenHeight - y;
+        blit_cursor();
+}
 
-        // Quick check to see if anything has to be drawn at all
-        if (w <= 0 || h <= 0)
+void OSystem_SDL::blit_cursor() {
+        byte *dstPtr;
+        const byte *srcPtr = _mouseData;
+        byte color;
+        int w, h;
+
+        if (!_mouseSurface)
                 return;
 
-        // Draw the mouse cursor; backup the covered area in "bak"
-        if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
-                error("SDL_LockSurface failed: %s", SDL_GetError());
+        w = _mouseCurState.w;
+        h = _mouseCurState.h;
 
-        // Mark as dirty
-        add_dirty_rect(x, y, w, h);
+        SDL_LockSurface(_mouseSurface);
+        dstPtr = (byte *)_mouseSurface->pixels;
 
-        if (!_overlayVisible) {
-                byte *bak = _mouseBackup;               // Surface used to backup the area obscured by the mouse
-                byte *dst;                                      // Surface we are drawing into
-        
-                dst = (byte *)_screen->pixels + y * _screenWidth + x;
-                while (h > 0) {
-                        int width = w;
-                        while (width > 0) {
-                                *bak++ = *dst;
-                                color = *src++;
-                                if (color != _mouseKeycolor)    // transparent, don't draw
-                                        *dst = color;
-                                dst++;
-                                width--;
-                        }
-                        src += _mouseCurState.w - w;
-                        bak += MAX_MOUSE_W - w;
-                        dst += _screenWidth - w;
-                        h--;
-                }
-        
-        } else {
-                uint16 *bak = (uint16 *)_mouseBackup;   // Surface used to backup the area obscured by the mouse
-                byte *dst;                                      // Surface we are drawing into
-        
-                dst = (byte *)_tmpscreen->pixels + (y + 1) * _tmpscreen->pitch + (x + 1) * 2;
-                while (h > 0) {
-                        int width = w;
-                        while (width > 0) {
-                                *bak++ = *(uint16 *)dst;
-                                color = *src++;
-                                if (color != 0xFF)      // 0xFF = transparent, don't draw
-                                        *(uint16 *)dst = RGBToColor(_currentPalette[color].r, _currentPalette[color].g, _currentPalette[color].b);
-                                dst += 2;
-                                width--;
+        for (int i = 0; i < h; i++) {
+                for (int j = 0; j < w; j++) {
+                        color = *srcPtr;
+                        if (color != _mouseKeycolor) {  // transparent, don't draw
+                                *(uint16 *)dstPtr = SDL_MapRGB(_mouseSurface->format, _currentPalette[color].r, 
+                                                                         _currentPalette[color].g, _currentPalette[color].b);
+                        } else {
+                                *(uint16 *)dstPtr = kMouseColorKey;
                         }
-                        src += _mouseCurState.w - w;
-                        bak += MAX_MOUSE_W - w;
-                        dst += _tmpscreen->pitch - w * 2;
-                        h--;
+                        dstPtr += 2;
+                        srcPtr++;
                 }
+                dstPtr += _mouseSurface->pitch - w * 2;
         }
+        SDL_UnlockSurface(_mouseSurface);
+}
 
-        SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
-
-        // Finally, set the flag to indicate the mouse has been drawn
-        _mouseDrawn = true;
+void OSystem_SDL::toggleMouseGrab() {
+        if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
+                SDL_WM_GrabInput(SDL_GRAB_ON);
+        else
+                SDL_WM_GrabInput(SDL_GRAB_OFF);
 }
 
 void OSystem_SDL::undraw_mouse() {
-        if (!_mouseDrawn)
+        if (_mouseBackup.w) {
+                if (_adjustAspectRatio)
+                        add_dirty_rect(_mouseBackup.x, aspect2Real(_mouseBackup.y), _mouseBackup.w, 
+                                                   _mouseBackup.h);
+                else
+                        add_dirty_rect(_mouseBackup.x, _mouseBackup.y, _mouseBackup.w, 
+                                                   _mouseBackup.h);
+        }
+}
+
+void OSystem_SDL::draw_mouse() {
+        if (!_mouseVisible) {
+                _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
                 return;
-        _mouseDrawn = false;
+        }
 
-        if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
-                error("SDL_LockSurface failed: %s", SDL_GetError());
+        SDL_Rect src, dst;
 
-        int old_mouse_x = _mouseCurState.x - _mouseHotspotX;
-        int old_mouse_y = _mouseCurState.y - _mouseHotspotY;
-        int old_mouse_w = _mouseCurState.w;
-        int old_mouse_h = _mouseCurState.h;
-
-        // clip the mouse rect, and addjust the src pointer accordingly
-        if (old_mouse_x < 0) {
-                old_mouse_w += old_mouse_x;
-                old_mouse_x = 0;
-        }
-        if (old_mouse_y < 0) {
-                old_mouse_h += old_mouse_y;
-                old_mouse_y = 0;
-        }
-
-        if (old_mouse_w > _screenWidth - old_mouse_x)
-                old_mouse_w = _screenWidth - old_mouse_x;
-        if (old_mouse_h > _screenHeight - old_mouse_y)
-                old_mouse_h = _screenHeight - old_mouse_y;
+        dst.x = _mouseCurState.x - _mouseHotspotX * _cursorScale;
+        dst.y = _mouseCurState.y - _mouseHotspotY * _cursorScale;
+        dst.w = _mouseCurState.w;
+        dst.h = _mouseCurState.h;
+        src.x = src.y = 0;
+
+        // clip the mouse rect, and adjust the src pointer accordingly
+        if (dst.x < 0) {
+                dst.w += dst.x;
+                src.x -= dst.x;
+                dst.x = 0;
+        }
+        if (dst.y < 0) {
+                dst.h += dst.y;
+                src.y -= dst.y;
+                dst.y = 0;
+        }
+
+        if (dst.w > _screenWidth - dst.x)
+                dst.w = _screenWidth - dst.x;
+        if (dst.h > _screenHeight - dst.y)
+                dst.h = _screenHeight - dst.y;
 
         // Quick check to see if anything has to be drawn at all
-        if (old_mouse_w <= 0 || old_mouse_h <= 0)
+        if (dst.w <= 0 || dst.h <= 0)
                 return;
 
+        src.w = dst.w;
+        src.h = dst.h;
 
-        int x, y;
-        if (!_overlayVisible) {
-                byte *dst, *bak = _mouseBackup;
-
-                // No need to do clipping here, since draw_mouse() did that already
-                dst = (byte *)_screen->pixels + old_mouse_y * _screenWidth + old_mouse_x;
-                for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _screenWidth) {
-                        for (x = 0; x < old_mouse_w; ++x) {
-                                dst[x] = bak[x];
-                        }
-                }
-        
-        } else {
+        if (_adjustAspectRatio)
+                dst.y = real2Aspect(dst.y);
 
-                byte *dst;
-                uint16 *bak = (uint16 *)_mouseBackup;
-        
-                // No need to do clipping here, since draw_mouse() did that already
-                dst = (byte *)_tmpscreen->pixels + (old_mouse_y + 1) * _tmpscreen->pitch + (old_mouse_x + 1) * 2;
-                for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _tmpscreen->pitch) {
-                        for (x = 0; x < old_mouse_w; ++x) {
-                                *((uint16 *)dst + x) = bak[x];
-                        }
-                }
-        }
+        _mouseBackup.x = dst.x;
+        _mouseBackup.y = dst.y;
+        _mouseBackup.w = dst.w;
+        _mouseBackup.h = dst.h;
 
-        add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
+        dst.x *= _scaleFactor;
+        dst.y *= _scaleFactor;
 
-        SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
-}
+        if (SDL_BlitSurface(_mouseSurface, &src, _hwscreen, &dst) != 0)
+                error("SDL_BlitSurface failed: %s", SDL_GetError());
 
+        add_dirty_rect(dst.x, dst.y, dst.w, dst.h, true);
+}
 
 #pragma mark -
 #pragma mark --- Mouse ---

backends/sdl/sdl-common.h

@@ -64 +64 @@
         void warpMouse(int x, int y);
 
         // Set the bitmap that's used when drawing the cursor.
-        void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor);
+        void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorScale);
 
         // Shaking is used in SCUMM. Set current shake position.
         void set_shake_pos(int shake_pos);
@@ -221 +221 @@
         bool _mouseVisible;
         bool _mouseDrawn;
         byte *_mouseData;
-        byte *_mouseBackup;
+        SDL_Rect _mouseBackup;
         MousePos _mouseCurState;
         int16 _mouseHotspotX;
         int16 _mouseHotspotY;
         byte _mouseKeycolor;
+        int _cursorScale;
+        SDL_Surface *_mouseSurface;
+        enum {
+                kMouseColorKey = 1
+        };
 
         // joystick
         SDL_Joystick *_joystick;
@@ -248 +253 @@
         void add_dirty_rgn_auto(const byte *buf);
         void mk_checksums(const byte *buf);
 
-        virtual void add_dirty_rect(int x, int y, int w, int h);
+        virtual void add_dirty_rect(int x, int y, int w, int h, bool mouseRect = false);
 
         void draw_mouse();
         void undraw_mouse();
+        void blit_cursor();
         /** Set the position of the virtual mouse cursor. */
         void set_mouse_pos(int x, int y);
         void fillMouseEvent(Event &event, int x, int y);

backends/sdl/sdl.cpp

@@ -97 +97 @@
         _tmpscreen(0), _overlayVisible(false),
         _samplesPerSec(0),
         _cdrom(0), _scaler_proc(0), _modeChanged(false), _dirty_checksums(0),
-        _mouseVisible(false), _mouseDrawn(false), _mouseData(0),
+        _mouseVisible(false), _mouseDrawn(false), _mouseData(0), _mouseSurface(0),
         _mouseHotspotX(0), _mouseHotspotY(0),
         _currentShakePos(0), _newShakePos(0),
         _paletteDirtyStart(0), _paletteDirtyEnd(0),
@@ -106 +106 @@
         // allocate palette storage
         _currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
 
-        // allocate the dirty rect storage
-        _mouseBackup = (byte *)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
+        _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
 
         // reset mouse state
         memset(&km, 0, sizeof(km));
@@ -121 +120 @@
         if (_dirty_checksums)
                 free(_dirty_checksums);
         free(_currentPalette);
-        free(_mouseBackup);
         deleteMutex(_graphicsMutex);
 
         SDL_ShowCursor(SDL_ENABLE);

common/scaler.cpp

@@ -169 +169 @@
         }
 }
 
+#define INTERPOLATE             INTERPOLATE<bitFormat>
+#define Q_INTERPOLATE   Q_INTERPOLATE<bitFormat>
+
+/**
+ * Trivial nearest-neighbour 1.5x scaler.
+ */
+template<int bitFormat>
+void Normal1o5xTemplate(const uint8 *srcPtr, uint32 srcPitch, uint8 *dstPtr, uint32 dstPitch,
+                                                        int width, int height) {
+        uint8 *r;
+        const uint32 dstPitch2 = dstPitch * 2;
+        const uint32 dstPitch3 = dstPitch * 3;
+        const uint32 srcPitch2 = srcPitch * 2;
+
+        assert(((int)dstPtr & 1) == 0);
+        while (height) {
+                r = dstPtr;
+                for (int i = 0; i < width; i += 2, r += 6) {
+                        uint16 color0 = *(((const uint16 *)srcPtr) + i);
+                        uint16 color1 = *(((const uint16 *)srcPtr) + i + 1);
+                        uint16 color2 = *(((const uint16 *)(srcPtr + srcPitch)) + i);
+                        uint16 color3 = *(((const uint16 *)(srcPtr + srcPitch)) + i + 1);
+
+                        *(uint16 *)(r + 0) = color0;
+                        *(uint16 *)(r + 2) = INTERPOLATE(color0, color1);
+                        *(uint16 *)(r + 4) = color1;
+                        *(uint16 *)(r + 0 + dstPitch) = INTERPOLATE(color0, color2);
+                        *(uint16 *)(r + 2 + dstPitch) = Q_INTERPOLATE(color0, color1, color2, color3);
+                        *(uint16 *)(r + 4 + dstPitch) = INTERPOLATE(color1, color3);
+                        *(uint16 *)(r + 0 + dstPitch2) = color2;
+                        *(uint16 *)(r + 2 + dstPitch2) = INTERPOLATE(color2, color3);
+                        *(uint16 *)(r + 4 + dstPitch2) = color3;
+                }
+                srcPtr += srcPitch2;
+                dstPtr += dstPitch3;
+                height -= 2;
+        }
+}
+MAKE_WRAPPER(Normal1o5x)
+
 /**
  * The Scale2x filter, also known as AdvMame2x.
  * See also http://scale2x.sourceforge.net

common/scaler.h

@@ -41 +41 @@
 DECLARE_SCALER(Normal1x);
 DECLARE_SCALER(Normal2x);
 DECLARE_SCALER(Normal3x);
+DECLARE_SCALER(Normal1o5x);
 DECLARE_SCALER(TV2x);
 DECLARE_SCALER(DotMatrix);
 DECLARE_SCALER(HQ2x);

common/system.h

@@ -345 +345 @@
          * @param hotspotY      vertical offset from the top side to the hotspot
          * @param keycolor      transparency color index
          */
-        virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor = 255) = 0;
+        virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor = 255, int cursorScale = 1) = 0;
 
         //@}