Ticket #8353: mouse.v1.diff

File mouse.v1.diff, 18.3 KB (added by sev-, 16 years ago)

Mouse on a separate surface v1 patch.

  • backends/sdl/graphics.cpp

    RCS file: /cvsroot/scummvm/scummvm/backends/sdl/graphics.cpp,v
    retrieving revision 1.12
    diff -u -r1.12 graphics.cpp
     
    4141        {0, 0, 0}
    4242};
    4343
     44// Table of relative scalers magnitudes
     45// [definedScale-1][_scaleFactor-1]
     46static ScalerProc *scalersMagn[3][3] = {
     47        { Normal1x, Normal2x, Normal3x },
     48        { Normal1x, Normal1x, Normal1o5x },
     49        { Normal1x, Normal1x, Normal1x }
     50};
     51
    4452const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
    4553        return s_supportedGraphicsModes;
    4654}
     
    327335                _forceFull = true;
    328336        }
    329337
    330         // Make sure the mouse is drawn, if it should be drawn.
    331         draw_mouse();
    332        
    333338        // Check whether the palette was changed in the meantime and update the
    334339        // screen surface accordingly.
    335340        if (_paletteDirtyEnd != 0) {
     
    362367        }
    363368#endif
    364369
     370        undraw_mouse();
     371
    365372        // Force a full redraw if requested
    366373        if (_forceFull) {
    367374                _num_dirty_rects = 1;
     
    457464                }
    458465#endif
    459466
     467                draw_mouse();
     468
    460469                // Finally, blit all our changes to the screen
    461470                SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
     471        } else {
     472                draw_mouse();
     473                if (_num_dirty_rects)
     474                        SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
    462475        }
    463476
    464477        _num_dirty_rects = 0;
     
    480493                assert(_hwscreen != 0);
    481494                _full_screen ^= true;
    482495
    483                 undraw_mouse();
    484        
    485496#if defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)
    486497                // On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse,
    487498                // before SDL 1.2.6 it always returned -1 (which would indicate a
     
    544555                add_dirty_rect(x, y, w, h);
    545556        }
    546557
    547         /* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
    548         undraw_mouse();
    549 
    550558        // Try to lock the screen surface
    551559        if (SDL_LockSurface(_screen) == -1)
    552560                error("SDL_LockSurface failed: %s", SDL_GetError());
     
    568576}
    569577
    570578
    571 void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
     579void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h, bool mouseRect) {
    572580        if (_forceFull)
    573581                return;
    574582
     583        if (mouseRect) {
     584                SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++];
     585                r->x = x;
     586                r->y = y;
     587                r->w = w;
     588                r->h = h;
     589                return;
     590        }
     591
    575592        if (_num_dirty_rects == NUM_DIRTY_RECT)
    576593                _forceFull = true;
    577594        else {
     
    718735
    719736        if (start + num > _paletteDirtyEnd)
    720737                _paletteDirtyEnd = start + num;
     738
     739        // Some games blink cursors with palette
     740        if (!_overlayVisible)
     741                blit_cursor();
    721742}
    722743
    723744void OSystem_SDL::set_shake_pos(int shake_pos) {
     
    730751#pragma mark -
    731752
    732753void OSystem_SDL::showOverlay() {
    733         // hide the mouse
    734         undraw_mouse();
    735 
    736754        _overlayVisible = true;
    737755        clearOverlay();
    738756}
    739757
    740758void OSystem_SDL::hideOverlay() {
    741         // hide the mouse
    742         undraw_mouse();
    743 
    744759        _overlayVisible = false;
    745760        _forceFull = true;
    746761}
     
    751766       
    752767        Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
    753768       
    754         // hide the mouse
    755         undraw_mouse();
    756 
    757769        // Clear the overlay by making the game screen "look through" everywhere.
    758770        SDL_Rect src, dst;
    759771        src.x = src.y = 0;
     
    773785        if (_tmpscreen == NULL)
    774786                return;
    775787
    776         // hide the mouse
    777         undraw_mouse();
    778 
    779788        if (SDL_LockSurface(_tmpscreen) == -1)
    780789                error("SDL_LockSurface failed: %s", SDL_GetError());
    781790
     
    824833        cksum_valid = false;
    825834        add_dirty_rect(x, y, w, h);
    826835
    827         /* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
    828         undraw_mouse();
    829 
    830836        if (SDL_LockSurface(_tmpscreen) == -1)
    831837                error("SDL_LockSurface failed: %s", SDL_GetError());
    832838
     
    860866        bool last = _mouseVisible;
    861867        _mouseVisible = visible;
    862868
    863         if (visible)
    864                 draw_mouse();
    865         else
    866                 undraw_mouse();
     869        updateScreen();
    867870
    868871        return last;
    869872}
    870873
    871874void OSystem_SDL::set_mouse_pos(int x, int y) {
    872875        if (x != _mouseCurState.x || y != _mouseCurState.y) {
    873                 undraw_mouse();
    874876                _mouseCurState.x = x;
    875877                _mouseCurState.y = y;
    876878                updateScreen();
     
    892894        }
    893895}
    894896       
    895 void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor) {
    896 
    897         undraw_mouse();
    898 
    899         assert(w <= MAX_MOUSE_W);
    900         assert(h <= MAX_MOUSE_H);
    901         _mouseCurState.w = w;
    902         _mouseCurState.h = h;
     897void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorScale) {
     898        byte *tmpPtr, *dstPtr;
     899        const byte *srcPtr = buf;
     900        int dstPitch;
    903901
    904902        _mouseHotspotX = hotspot_x;
    905903        _mouseHotspotY = hotspot_y;
    906904
    907905        _mouseKeycolor = keycolor;
    908906
    909         if (_mouseData)
    910                 free(_mouseData);
     907        _cursorScale = cursorScale;
    911908
    912         _mouseData = (byte *)malloc(w * h);
    913         memcpy(_mouseData, buf, w * h);
    914 }
     909        if (_mouseCurState.w != (int)w * cursorScale || _mouseCurState.h != (int)h * cursorScale) {
     910                _mouseCurState.w = w * cursorScale;
     911                _mouseCurState.h = h * cursorScale;
     912
     913                if (_mouseSurface)
     914                        SDL_FreeSurface(_mouseSurface);
     915
     916                _mouseSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
     917                                                _mouseCurState.w,
     918                                                _mouseCurState.h,
     919                                                16,
     920                                                _hwscreen->format->Rmask,
     921                                                _hwscreen->format->Gmask,
     922                                                _hwscreen->format->Bmask,
     923                                                _hwscreen->format->Amask);
    915924
    916 void OSystem_SDL::toggleMouseGrab() {
    917         if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
    918                 SDL_WM_GrabInput(SDL_GRAB_ON);
    919         else
    920                 SDL_WM_GrabInput(SDL_GRAB_OFF);
    921 }
     925                if (_mouseSurface == NULL)
     926                        error("allocating _mouseSurface failed");
     927                SDL_SetColorKey(_mouseSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
     928        }
    922929
    923 void OSystem_SDL::draw_mouse() {
    924         if (_mouseDrawn || !_mouseVisible)
    925                 return;
     930        if (_mouseData)
     931                free(_mouseData);
    926932
    927         int x = _mouseCurState.x - _mouseHotspotX;
    928         int y = _mouseCurState.y - _mouseHotspotY;
    929         int w = _mouseCurState.w;
    930         int h = _mouseCurState.h;
    931         byte color;
    932         const byte *src = _mouseData;           // Image representing the mouse
     933        dstPtr = _mouseData = (byte *)malloc(w * h * cursorScale * cursorScale);
    933934
    934         // clip the mouse rect, and addjust the src pointer accordingly
    935         if (x < 0) {
    936                 w += x;
    937                 src -= x;
    938                 x = 0;
     935        if (cursorScale == 1) {
     936                memcpy(_mouseData, buf, w * h);
     937                blit_cursor();
     938                return;
    939939        }
    940         if (y < 0) {
    941                 h += y;
    942                 src -= y * _mouseCurState.w;
    943                 y = 0;
     940
     941        dstPitch = w * cursorScale;
     942        for (uint i = 0; i < h; i++) {
     943                for (uint j = 0; j < w; j++) {
     944                        for (int k = 0; k < cursorScale; k++) {
     945                                tmpPtr = dstPtr + dstPitch * k;
     946                                for (int l = 0; l < cursorScale; l++) {
     947                                        *tmpPtr++ = *srcPtr;
     948                                }
     949                        }
     950                        srcPtr++;
     951                        dstPtr += cursorScale;
     952                }
     953                dstPtr += dstPitch * (cursorScale - 1);
    944954        }
    945955
    946         if (w > _screenWidth - x)
    947                 w = _screenWidth - x;
    948         if (h > _screenHeight - y)
    949                 h = _screenHeight - y;
     956        blit_cursor();
     957}
    950958
    951         // Quick check to see if anything has to be drawn at all
    952         if (w <= 0 || h <= 0)
     959void OSystem_SDL::blit_cursor() {
     960        byte *dstPtr;
     961        const byte *srcPtr = _mouseData;
     962        byte color;
     963        int w, h;
     964
     965        if (!_mouseSurface)
    953966                return;
    954967
    955         // Draw the mouse cursor; backup the covered area in "bak"
    956         if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
    957                 error("SDL_LockSurface failed: %s", SDL_GetError());
     968        w = _mouseCurState.w;
     969        h = _mouseCurState.h;
    958970
    959         // Mark as dirty
    960         add_dirty_rect(x, y, w, h);
     971        SDL_LockSurface(_mouseSurface);
     972        dstPtr = (byte *)_mouseSurface->pixels;
    961973
    962         if (!_overlayVisible) {
    963                 byte *bak = _mouseBackup;               // Surface used to backup the area obscured by the mouse
    964                 byte *dst;                                      // Surface we are drawing into
    965        
    966                 dst = (byte *)_screen->pixels + y * _screenWidth + x;
    967                 while (h > 0) {
    968                         int width = w;
    969                         while (width > 0) {
    970                                 *bak++ = *dst;
    971                                 color = *src++;
    972                                 if (color != _mouseKeycolor)    // transparent, don't draw
    973                                         *dst = color;
    974                                 dst++;
    975                                 width--;
    976                         }
    977                         src += _mouseCurState.w - w;
    978                         bak += MAX_MOUSE_W - w;
    979                         dst += _screenWidth - w;
    980                         h--;
    981                 }
    982        
    983         } else {
    984                 uint16 *bak = (uint16 *)_mouseBackup;   // Surface used to backup the area obscured by the mouse
    985                 byte *dst;                                      // Surface we are drawing into
    986        
    987                 dst = (byte *)_tmpscreen->pixels + (y + 1) * _tmpscreen->pitch + (x + 1) * 2;
    988                 while (h > 0) {
    989                         int width = w;
    990                         while (width > 0) {
    991                                 *bak++ = *(uint16 *)dst;
    992                                 color = *src++;
    993                                 if (color != 0xFF)      // 0xFF = transparent, don't draw
    994                                         *(uint16 *)dst = RGBToColor(_currentPalette[color].r, _currentPalette[color].g, _currentPalette[color].b);
    995                                 dst += 2;
    996                                 width--;
     974        for (int i = 0; i < h; i++) {
     975                for (int j = 0; j < w; j++) {
     976                        color = *srcPtr;
     977                        if (color != _mouseKeycolor) {  // transparent, don't draw
     978                                *(uint16 *)dstPtr = SDL_MapRGB(_mouseSurface->format, _currentPalette[color].r,
     979                                                                         _currentPalette[color].g, _currentPalette[color].b);
     980                        } else {
     981                                *(uint16 *)dstPtr = kMouseColorKey;
    997982                        }
    998                         src += _mouseCurState.w - w;
    999                         bak += MAX_MOUSE_W - w;
    1000                         dst += _tmpscreen->pitch - w * 2;
    1001                         h--;
     983                        dstPtr += 2;
     984                        srcPtr++;
    1002985                }
     986                dstPtr += _mouseSurface->pitch - w * 2;
    1003987        }
     988        SDL_UnlockSurface(_mouseSurface);
     989}
    1004990
    1005         SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
    1006 
    1007         // Finally, set the flag to indicate the mouse has been drawn
    1008         _mouseDrawn = true;
     991void OSystem_SDL::toggleMouseGrab() {
     992        if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
     993                SDL_WM_GrabInput(SDL_GRAB_ON);
     994        else
     995                SDL_WM_GrabInput(SDL_GRAB_OFF);
    1009996}
    1010997
    1011998void OSystem_SDL::undraw_mouse() {
    1012         if (!_mouseDrawn)
     999        if (_mouseBackup.w) {
     1000                if (_adjustAspectRatio)
     1001                        add_dirty_rect(_mouseBackup.x, aspect2Real(_mouseBackup.y), _mouseBackup.w,
     1002                                                   _mouseBackup.h);
     1003                else
     1004                        add_dirty_rect(_mouseBackup.x, _mouseBackup.y, _mouseBackup.w,
     1005                                                   _mouseBackup.h);
     1006        }
     1007}
     1008
     1009void OSystem_SDL::draw_mouse() {
     1010        if (!_mouseVisible) {
     1011                _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
    10131012                return;
    1014         _mouseDrawn = false;
     1013        }
    10151014
    1016         if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
    1017                 error("SDL_LockSurface failed: %s", SDL_GetError());
     1015        SDL_Rect src, dst;
    10181016
    1019         int old_mouse_x = _mouseCurState.x - _mouseHotspotX;
    1020         int old_mouse_y = _mouseCurState.y - _mouseHotspotY;
    1021         int old_mouse_w = _mouseCurState.w;
    1022         int old_mouse_h = _mouseCurState.h;
    1023 
    1024         // clip the mouse rect, and addjust the src pointer accordingly
    1025         if (old_mouse_x < 0) {
    1026                 old_mouse_w += old_mouse_x;
    1027                 old_mouse_x = 0;
    1028         }
    1029         if (old_mouse_y < 0) {
    1030                 old_mouse_h += old_mouse_y;
    1031                 old_mouse_y = 0;
    1032         }
    1033 
    1034         if (old_mouse_w > _screenWidth - old_mouse_x)
    1035                 old_mouse_w = _screenWidth - old_mouse_x;
    1036         if (old_mouse_h > _screenHeight - old_mouse_y)
    1037                 old_mouse_h = _screenHeight - old_mouse_y;
     1017        dst.x = _mouseCurState.x - _mouseHotspotX * _cursorScale;
     1018        dst.y = _mouseCurState.y - _mouseHotspotY * _cursorScale;
     1019        dst.w = _mouseCurState.w;
     1020        dst.h = _mouseCurState.h;
     1021        src.x = src.y = 0;
     1022
     1023        // clip the mouse rect, and adjust the src pointer accordingly
     1024        if (dst.x < 0) {
     1025                dst.w += dst.x;
     1026                src.x -= dst.x;
     1027                dst.x = 0;
     1028        }
     1029        if (dst.y < 0) {
     1030                dst.h += dst.y;
     1031                src.y -= dst.y;
     1032                dst.y = 0;
     1033        }
     1034
     1035        if (dst.w > _screenWidth - dst.x)
     1036                dst.w = _screenWidth - dst.x;
     1037        if (dst.h > _screenHeight - dst.y)
     1038                dst.h = _screenHeight - dst.y;
    10381039
    10391040        // Quick check to see if anything has to be drawn at all
    1040         if (old_mouse_w <= 0 || old_mouse_h <= 0)
     1041        if (dst.w <= 0 || dst.h <= 0)
    10411042                return;
    10421043
     1044        src.w = dst.w;
     1045        src.h = dst.h;
    10431046
    1044         int x, y;
    1045         if (!_overlayVisible) {
    1046                 byte *dst, *bak = _mouseBackup;
    1047 
    1048                 // No need to do clipping here, since draw_mouse() did that already
    1049                 dst = (byte *)_screen->pixels + old_mouse_y * _screenWidth + old_mouse_x;
    1050                 for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _screenWidth) {
    1051                         for (x = 0; x < old_mouse_w; ++x) {
    1052                                 dst[x] = bak[x];
    1053                         }
    1054                 }
    1055        
    1056         } else {
     1047        if (_adjustAspectRatio)
     1048                dst.y = real2Aspect(dst.y);
    10571049
    1058                 byte *dst;
    1059                 uint16 *bak = (uint16 *)_mouseBackup;
    1060        
    1061                 // No need to do clipping here, since draw_mouse() did that already
    1062                 dst = (byte *)_tmpscreen->pixels + (old_mouse_y + 1) * _tmpscreen->pitch + (old_mouse_x + 1) * 2;
    1063                 for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _tmpscreen->pitch) {
    1064                         for (x = 0; x < old_mouse_w; ++x) {
    1065                                 *((uint16 *)dst + x) = bak[x];
    1066                         }
    1067                 }
    1068         }
     1050        _mouseBackup.x = dst.x;
     1051        _mouseBackup.y = dst.y;
     1052        _mouseBackup.w = dst.w;
     1053        _mouseBackup.h = dst.h;
    10691054
    1070         add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
     1055        dst.x *= _scaleFactor;
     1056        dst.y *= _scaleFactor;
    10711057
    1072         SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
    1073 }
     1058        if (SDL_BlitSurface(_mouseSurface, &src, _hwscreen, &dst) != 0)
     1059                error("SDL_BlitSurface failed: %s", SDL_GetError());
    10741060
     1061        add_dirty_rect(dst.x, dst.y, dst.w, dst.h, true);
     1062}
    10751063
    10761064#pragma mark -
    10771065#pragma mark --- Mouse ---
  • backends/sdl/sdl-common.h

    RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl-common.h,v
    retrieving revision 1.63
    diff -u -r1.63 sdl-common.h
     
    6464        void warpMouse(int x, int y);
    6565
    6666        // Set the bitmap that's used when drawing the cursor.
    67         void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor);
     67        void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorScale);
    6868
    6969        // Shaking is used in SCUMM. Set current shake position.
    7070        void set_shake_pos(int shake_pos);
     
    221221        bool _mouseVisible;
    222222        bool _mouseDrawn;
    223223        byte *_mouseData;
    224         byte *_mouseBackup;
     224        SDL_Rect _mouseBackup;
    225225        MousePos _mouseCurState;
    226226        int16 _mouseHotspotX;
    227227        int16 _mouseHotspotY;
    228228        byte _mouseKeycolor;
     229        int _cursorScale;
     230        SDL_Surface *_mouseSurface;
     231        enum {
     232                kMouseColorKey = 1
     233        };
    229234
    230235        // joystick
    231236        SDL_Joystick *_joystick;
     
    248253        void add_dirty_rgn_auto(const byte *buf);
    249254        void mk_checksums(const byte *buf);
    250255
    251         virtual void add_dirty_rect(int x, int y, int w, int h);
     256        virtual void add_dirty_rect(int x, int y, int w, int h, bool mouseRect = false);
    252257
    253258        void draw_mouse();
    254259        void undraw_mouse();
     260        void blit_cursor();
    255261        /** Set the position of the virtual mouse cursor. */
    256262        void set_mouse_pos(int x, int y);
    257263        void fillMouseEvent(Event &event, int x, int y);
  • backends/sdl/sdl.cpp

    RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl.cpp,v
    retrieving revision 1.72
    diff -u -r1.72 sdl.cpp
     
    9797        _tmpscreen(0), _overlayVisible(false),
    9898        _samplesPerSec(0),
    9999        _cdrom(0), _scaler_proc(0), _modeChanged(false), _dirty_checksums(0),
    100         _mouseVisible(false), _mouseDrawn(false), _mouseData(0),
     100        _mouseVisible(false), _mouseDrawn(false), _mouseData(0), _mouseSurface(0),
    101101        _mouseHotspotX(0), _mouseHotspotY(0),
    102102        _currentShakePos(0), _newShakePos(0),
    103103        _paletteDirtyStart(0), _paletteDirtyEnd(0),
     
    106106        // allocate palette storage
    107107        _currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
    108108
    109         // allocate the dirty rect storage
    110         _mouseBackup = (byte *)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
     109        _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
    111110
    112111        // reset mouse state
    113112        memset(&km, 0, sizeof(km));
     
    121120        if (_dirty_checksums)
    122121                free(_dirty_checksums);
    123122        free(_currentPalette);
    124         free(_mouseBackup);
    125123        deleteMutex(_graphicsMutex);
    126124
    127125        SDL_ShowCursor(SDL_ENABLE);
  • common/scaler.cpp

    RCS file: /cvsroot/scummvm/scummvm/common/scaler.cpp,v
    retrieving revision 1.63
    diff -u -r1.63 scaler.cpp
     
    169169        }
    170170}
    171171
     172#define INTERPOLATE             INTERPOLATE<bitFormat>
     173#define Q_INTERPOLATE   Q_INTERPOLATE<bitFormat>
     174
     175/**
     176 * Trivial nearest-neighbour 1.5x scaler.
     177 */
     178template<int bitFormat>
     179void Normal1o5xTemplate(const uint8 *srcPtr, uint32 srcPitch, uint8 *dstPtr, uint32 dstPitch,
     180                                                        int width, int height) {
     181        uint8 *r;
     182        const uint32 dstPitch2 = dstPitch * 2;
     183        const uint32 dstPitch3 = dstPitch * 3;
     184        const uint32 srcPitch2 = srcPitch * 2;
     185
     186        assert(((int)dstPtr & 1) == 0);
     187        while (height) {
     188                r = dstPtr;
     189                for (int i = 0; i < width; i += 2, r += 6) {
     190                        uint16 color0 = *(((const uint16 *)srcPtr) + i);
     191                        uint16 color1 = *(((const uint16 *)srcPtr) + i + 1);
     192                        uint16 color2 = *(((const uint16 *)(srcPtr + srcPitch)) + i);
     193                        uint16 color3 = *(((const uint16 *)(srcPtr + srcPitch)) + i + 1);
     194
     195                        *(uint16 *)(r + 0) = color0;
     196                        *(uint16 *)(r + 2) = INTERPOLATE(color0, color1);
     197                        *(uint16 *)(r + 4) = color1;
     198                        *(uint16 *)(r + 0 + dstPitch) = INTERPOLATE(color0, color2);
     199                        *(uint16 *)(r + 2 + dstPitch) = Q_INTERPOLATE(color0, color1, color2, color3);
     200                        *(uint16 *)(r + 4 + dstPitch) = INTERPOLATE(color1, color3);
     201                        *(uint16 *)(r + 0 + dstPitch2) = color2;
     202                        *(uint16 *)(r + 2 + dstPitch2) = INTERPOLATE(color2, color3);
     203                        *(uint16 *)(r + 4 + dstPitch2) = color3;
     204                }
     205                srcPtr += srcPitch2;
     206                dstPtr += dstPitch3;
     207                height -= 2;
     208        }
     209}
     210MAKE_WRAPPER(Normal1o5x)
     211
    172212/**
    173213 * The Scale2x filter, also known as AdvMame2x.
    174214 * See also http://scale2x.sourceforge.net
  • common/scaler.h

    RCS file: /cvsroot/scummvm/scummvm/common/scaler.h,v
    retrieving revision 1.26
    diff -u -r1.26 scaler.h
     
    4141DECLARE_SCALER(Normal1x);
    4242DECLARE_SCALER(Normal2x);
    4343DECLARE_SCALER(Normal3x);
     44DECLARE_SCALER(Normal1o5x);
    4445DECLARE_SCALER(TV2x);
    4546DECLARE_SCALER(DotMatrix);
    4647DECLARE_SCALER(HQ2x);
  • common/system.h

    RCS file: /cvsroot/scummvm/scummvm/common/system.h,v
    retrieving revision 1.69
    diff -u -r1.69 system.h
     
    345345         * @param hotspotY      vertical offset from the top side to the hotspot
    346346         * @param keycolor      transparency color index
    347347         */
    348         virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor = 255) = 0;
     348        virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor = 255, int cursorScale = 1) = 0;
    349349
    350350        //@}
    351351