Ticket #4774: made.patch

File made.patch, 13.0 KB (added by johndoe123, 10 years ago)

Patch for screen effects

  • screenfx.cpp

     
    6161}
    6262
    6363void ScreenEffects::run(int16 effectNum, Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
    64         // Workaround: we set up the final palette beforehand, to reduce CPU usage during the screen effect.
    65         // The visual difference is not noticeable, but CPU load is much much less (as palette updates are very expensive).
    66         // The palette changes in the effects have been removed, where applicable, to reduce CPU load
    67         setPalette(palette);
    6864
    6965        // TODO: Put effect functions into an array
    70 
     66       
    7167        switch (effectNum) {
    7268
    7369        case 0:         // No effect
     
    191187        }
    192188}
    193189
     190void ScreenEffects::startBlendedPalette(byte *palette, byte *newPalette, int colorCount, int16 maxValue) {
     191        _blendedPaletteStatus._palette = palette;
     192        _blendedPaletteStatus._newPalette = newPalette;
     193        _blendedPaletteStatus._colorCount = colorCount;
     194        _blendedPaletteStatus._maxValue = maxValue;
     195        _blendedPaletteStatus._incr = maxValue / 10; // ~10 palette updates
     196        _blendedPaletteStatus._value = 0;
     197        // Don't do anything if the two palettes are identical
     198        _blendedPaletteStatus._active = memcmp(palette, newPalette, colorCount * 3) != 0;
     199}
     200
     201void ScreenEffects::stepBlendedPalette() {
     202        if (_blendedPaletteStatus._active && _blendedPaletteStatus._value < _blendedPaletteStatus._maxValue) {
     203                setBlendedPalette(_blendedPaletteStatus._palette, _blendedPaletteStatus._newPalette,
     204                        _blendedPaletteStatus._colorCount, _blendedPaletteStatus._value, _blendedPaletteStatus._maxValue);
     205                if (_blendedPaletteStatus._value == _blendedPaletteStatus._maxValue)
     206                        _blendedPaletteStatus._value++;
     207                else                                   
     208                        _blendedPaletteStatus._value = MIN<int16>(_blendedPaletteStatus._value + _blendedPaletteStatus._incr, _blendedPaletteStatus._maxValue);
     209        }               
     210}
     211       
    194212void ScreenEffects::copyFxRect(Graphics::Surface *surface, int16 x1, int16 y1, int16 x2, int16 y2) {
    195213
    196214        // TODO: Clean up
     
    276294}
    277295
    278296void ScreenEffects::vfx01(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     297        startBlendedPalette(palette, newPalette, colorCount, 312);
    279298        for (int x = 0; x < 320; x += 8) {
    280299                _screen->copyRectToScreen((const byte*)surface->getBasePtr(x, 0), surface->pitch, x, 0, 8, 200);
    281                 //setBlendedPalette(palette, newPalette, colorCount, x, 312);           // original behavior
     300                stepBlendedPalette();
    282301                _screen->updateScreenAndWait(25);
    283302        }
    284         //setPalette(palette);          // original behavior
     303        setPalette(palette);
    285304}
    286305
    287306void ScreenEffects::vfx02(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     307        startBlendedPalette(palette, newPalette, colorCount, 312);
    288308        for (int x = 312; x >= 0; x -= 8) {
    289309                _screen->copyRectToScreen((const byte*)surface->getBasePtr(x, 0), surface->pitch, x, 0, 8, 200);
    290                 //setBlendedPalette(palette, newPalette, colorCount, 312 - x, 312);             // original behavior
     310                stepBlendedPalette();
    291311                _screen->updateScreenAndWait(25);
    292312        }
    293         //setPalette(palette);          // original behavior
     313        setPalette(palette);
    294314}
    295315
    296316void ScreenEffects::vfx03(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     317        startBlendedPalette(palette, newPalette, colorCount, 190);
    297318        for (int y = 0; y < 200; y += 10) {
    298319                _screen->copyRectToScreen((const byte*)surface->getBasePtr(0, y), surface->pitch, 0, y, 320, 10);
    299                 //setBlendedPalette(palette, newPalette, colorCount, y, 190);           // original behavior
     320                stepBlendedPalette();
    300321                _screen->updateScreenAndWait(25);
    301322        }
    302         //setPalette(palette);          // original behavior
     323        setPalette(palette);
    303324}
    304325
    305326void ScreenEffects::vfx04(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     327        startBlendedPalette(palette, newPalette, colorCount, 190);
    306328        for (int y = 190; y >= 0; y -= 10) {
    307329                _screen->copyRectToScreen((const byte*)surface->getBasePtr(0, y), surface->pitch, 0, y, 320, 10);
    308                 //setBlendedPalette(palette, newPalette, colorCount, 190 - y, 190);             // original behavior
     330                stepBlendedPalette();
    309331                _screen->updateScreenAndWait(25);
    310332        }
    311         //setPalette(palette);          // original behavior
     333        setPalette(palette);
    312334}
    313335
    314336void ScreenEffects::vfx05(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     337        startBlendedPalette(palette, newPalette, colorCount, 90);
    315338        for (int y = 0; y < 100; y += 10) {
    316339                _screen->copyRectToScreen((const byte*)surface->getBasePtr(0, y + 100), surface->pitch, 0, y + 100, 320, 10);
    317340                _screen->copyRectToScreen((const byte*)surface->getBasePtr(0, 90 - y), surface->pitch, 0, 90 - y, 320, 10);
    318                 //setBlendedPalette(palette, newPalette, colorCount, y, 90);            // original behavior
     341                stepBlendedPalette();
    319342                _screen->updateScreenAndWait(25);
    320343        }
    321         //setPalette(palette);          // original behavior
     344        setPalette(palette);
    322345}
    323346
    324347// "Curtain open" effect
    325348void ScreenEffects::vfx06(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     349        startBlendedPalette(palette, newPalette, colorCount, 152);
    326350        for (int x = 0; x < 160; x += 8) {
    327351                _screen->copyRectToScreen((const byte*)surface->getBasePtr(x + 160, 0), surface->pitch, x + 160, 0, 8, 200);
    328352                _screen->copyRectToScreen((const byte*)surface->getBasePtr(152 - x, 0), surface->pitch, 152 - x, 0, 8, 200);
    329                 //setBlendedPalette(palette, newPalette, colorCount, x, 152);           // original behavior
     353                stepBlendedPalette();
    330354                _screen->updateScreenAndWait(25);
    331355        }
    332         //setPalette(palette);          // original behavior
     356        setPalette(palette);
    333357}
    334358
    335359// "Curtain close" effect
    336360void ScreenEffects::vfx07(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     361        startBlendedPalette(palette, newPalette, colorCount, 152);
    337362        for (int x = 152; x >= 0; x -= 8) {
    338363                _screen->copyRectToScreen((const byte*)surface->getBasePtr(x + 160, 0), surface->pitch, x + 160, 0, 8, 200);
    339364                _screen->copyRectToScreen((const byte*)surface->getBasePtr(152 - x, 0), surface->pitch, 152 - x, 0, 8, 200);
    340                 //setBlendedPalette(palette, newPalette, colorCount, 152 - x, 152);             // original behavior
     365                stepBlendedPalette();
    341366                _screen->updateScreenAndWait(25);
    342367        }
    343         //setPalette(palette);          // original behavior
     368        setPalette(palette);
    344369}
    345370
    346371// "Screen slide in" right to left
     
    349374                _screen->copyRectToScreen((const byte*)surface->getBasePtr(0, 0), surface->pitch, 320 - x, 0, x, 200);
    350375                _screen->updateScreenAndWait(25);
    351376        }
    352         //setPalette(palette);          // original behavior
     377        setPalette(palette);
    353378}
    354379
    355380// "Checkerboard" effect
     
    368393
    369394// "Screen wipe in", left to right
    370395void ScreenEffects::vfx10(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     396        startBlendedPalette(palette, newPalette, colorCount, 368);
    371397        for (int x = -56; x < 312; x += 8) {
    372398                copyFxRect(surface, x, 0, x + 64, 200);
    373                 //setBlendedPalette(palette, newPalette, colorCount, x + 56, 368);              // original behavior
     399                stepBlendedPalette();
    374400                _screen->updateScreenAndWait(25);
    375401        }
    376         //setPalette(palette);          // original behavior
     402        setPalette(palette);
    377403}
    378404
    379405// "Screen wipe in", right to left
    380406void ScreenEffects::vfx11(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     407        startBlendedPalette(palette, newPalette, colorCount, 368);
    381408        for (int x = 312; x > -56; x -= 8) {
    382409                copyFxRect(surface, x, 0, x + 64, 200);
    383                 //setBlendedPalette(palette, newPalette, colorCount, x + 56, 368);              // original behavior
     410                stepBlendedPalette();
    384411                _screen->updateScreenAndWait(25);
    385412        }
    386         //setPalette(palette);          // original behavior
     413        setPalette(palette);
    387414}
    388415
    389416// "Screen wipe in", top to bottom
    390417void ScreenEffects::vfx12(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     418        startBlendedPalette(palette, newPalette, colorCount, 260);
    391419        for (int y = -70; y < 312; y += 10) {
    392420                copyFxRect(surface, 0, y, 320, y + 80);
    393                 //setBlendedPalette(palette, newPalette, colorCount, y + 70, 260);              // original behavior
     421                stepBlendedPalette();
    394422                _screen->updateScreenAndWait(25);
    395423        }
    396         //setPalette(palette);          // original behavior
     424        setPalette(palette);
    397425}
    398426
    399427// "Screen wipe in", bottom to top
    400428void ScreenEffects::vfx13(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
     429        startBlendedPalette(palette, newPalette, colorCount, 260);
    401430        for (int y = 312; y > -70; y -= 10) {
    402431                copyFxRect(surface, 0, y, 320, y + 80);
    403                 //setBlendedPalette(palette, newPalette, colorCount, y + 70, 260);              // original behavior
     432                stepBlendedPalette();
    404433                _screen->updateScreenAndWait(25);
    405434        }
    406         //setPalette(palette);          // original behavior
     435        setPalette(palette);
    407436}
    408437
    409438// "Screen open" effect
    410439void ScreenEffects::vfx14(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
    411440        int16 x = 8, y = 5;
     441        startBlendedPalette(palette, newPalette, colorCount, 27);
    412442        for (int i = 0; i < 27; i++) {
    413443                copyFxRect(surface, 160 - x, 100 - y, 160 + x, 100 + y);
    414444                x += 8;
    415445                y += 5;
    416                 //setBlendedPalette(palette, newPalette, colorCount, i, 27);            // original behavior
     446                stepBlendedPalette();
    417447                _screen->updateScreenAndWait(25);
    418448        }
    419         //setPalette(palette);          // original behavior
     449        setPalette(palette);
    420450}
    421451
    422452void ScreenEffects::vfx15(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
    423453        int16 x = 8;
     454        startBlendedPalette(palette, newPalette, colorCount, 27);
    424455        for (int i = 0; i < 27; i++) {
    425456                copyFxRect(surface, 160 - x, 0, 160 + x, 200);
    426457                x += 8;
    427                 //setBlendedPalette(palette, newPalette, colorCount, i, 27);            // original behavior
     458                stepBlendedPalette();
    428459                _screen->updateScreenAndWait(25);
    429460        }
    430         //setPalette(palette);          // original behavior
     461        setPalette(palette);
    431462}
    432463
    433464void ScreenEffects::vfx16(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
    434465        int16 y = 8;
     466        startBlendedPalette(palette, newPalette, colorCount, 27);
    435467        for (int i = 0; i < 27; i++) {
    436468                copyFxRect(surface, 0, 100 - y, 320, 100 + y);
    437469                y += 5;
    438                 //setBlendedPalette(palette, newPalette, colorCount, i, 27);            // original behavior
     470                stepBlendedPalette();
    439471                _screen->updateScreenAndWait(25);
    440472        }
    441         //setPalette(palette);          // original behavior
     473        setPalette(palette);
    442474}
    443475
    444476// Palette fadeout/fadein
     
    451483
    452484        memcpy(tempPalette, palette, 768);
    453485
    454         // We reduce the number of palette updates by the following factor (e.g. a factor of 5 would mean 5
    455         // times less updates). This is done to reduce CPU load while performing the very expensive full
    456         // screen palette changes. The original behavior is to set factor to 1.
    457         int factor = 5;
    458 
    459486        // Fade out to black
    460487        memset(palette, 0, 768);
    461         for (int i = 0; i < 50 / factor; i++) {
    462                 setBlendedPalette(palette, newPalette, colorCount, i * factor, 50);
    463                 _screen->updateScreenAndWait(25 * factor);
     488        startBlendedPalette(palette, newPalette, colorCount, 50);
     489        for (int i = 0; i < 50; i++) {
     490                stepBlendedPalette();
     491                _screen->updateScreenAndWait(25);
    464492        }
    465493        _screen->setRGBPalette(palette, 0, colorCount);
    466494
     
    470498
    471499        // Fade from black to palette
    472500        memset(newPalette, 0, 768);
    473         for (int i = 0; i < 50 / factor; i++) {
    474                 setBlendedPalette(palette, newPalette, colorCount, i * factor, 50);
    475                 _screen->updateScreenAndWait(25 * factor);
     501        startBlendedPalette(palette, newPalette, colorCount, 50);
     502        for (int i = 0; i < 50; i++) {
     503                stepBlendedPalette();
     504                _screen->updateScreenAndWait(25);
    476505        }
    477506        _screen->setRGBPalette(palette, 0, colorCount);
    478507
     
    486515                _screen->copyRectToScreen((const byte*)surface->getBasePtr(320 - x, 0), surface->pitch, 0, 0, x, 200);
    487516                _screen->updateScreenAndWait(25);
    488517        }
    489 
    490         //setPalette(palette);          // original behavior
     518        setPalette(palette);
    491519}
    492520
    493521// "Screen slide in" top to bottom
     
    496524                _screen->copyRectToScreen((const byte*)surface->getBasePtr(0, 200 - y), surface->pitch, 0, 0, 320, y);
    497525                _screen->updateScreenAndWait(25);
    498526        }
    499 
    500         //setPalette(palette);          // original behavior
     527        setPalette(palette);
    501528}
    502529
    503530// "Screen slide in" bottom to top
     
    506533                _screen->copyRectToScreen((const byte*)surface->getBasePtr(0, 0), surface->pitch, 0, 200 - y, 320, y);
    507534                _screen->updateScreenAndWait(25);
    508535        }
    509 
    510         //setPalette(palette);          // original behavior
     536        setPalette(palette);
    511537}
    512538
    513539} // End of namespace Made
  • screenfx.h

     
    3737
    3838namespace Made {
    3939
     40struct BlendedPaletteStatus {
     41        bool _active;
     42        byte *_palette, *_newPalette;
     43        int _colorCount;
     44        int16 _value, _maxValue, _incr;
     45        int cnt;
     46};
     47
    4048class ScreenEffects {
    4149public:
    4250        ScreenEffects(Screen *screen);
     
    5058        static const byte vfxOffsIndexTable[8];
    5159        const byte *vfxOffsTablePtr;
    5260        int16 vfxX1, vfxY1, vfxWidth, vfxHeight;
     61        BlendedPaletteStatus _blendedPaletteStatus;
    5362        void setPalette(byte *palette);
    5463        void setBlendedPalette(byte *palette, byte *newPalette, int colorCount, int16 value, int16 maxValue);
     64        void startBlendedPalette(byte *palette, byte *newPalette, int colorCount, int16 maxValue);
     65        void stepBlendedPalette();
    5566        void copyFxRect(Graphics::Surface *surface, int16 x1, int16 y1, int16 x2, int16 y2);
    5667
    5768        void vfx00(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);