Ticket #8046: savepalmanipulate.diff

File savepalmanipulate.diff, 10.1 KB (added by SF/jamieson630, 18 years ago)

Intermediate palManipulate load/save solution

  • scummvm/scumm/gfx.cpp

    RCS file: /cvsroot/scummvm/scummvm/scumm/gfx.cpp,v
    retrieving revision 1.17
    diff -u -r1.17 gfx.cpp
     
    554554        byte *startptr2, *endptr2;
    555555        int num;
    556556        byte tmp[6];
    557         byte tmp2[6];
    558557
    559558        if (!_palManipCounter)
    560559                return;
    561560
    562         startptr = getResourceAddress(rtTemp, 4) + start * 6;
    563         endptr = getResourceAddress(rtTemp, 4) + end * 6;
    564 
    565         startptr2 = getResourceAddress(rtTemp, 5) + start * 6;
    566         endptr2 = getResourceAddress(rtTemp, 5) + end * 6;
    567 
     561        startptr = _palManipPalette + start * 3;
     562        endptr = _palManipPalette + end * 3;
     563        startptr2 = _palManipIntermediatePal + start * 6;
     564        endptr2 = _palManipIntermediatePal + end * 6;
    568565        num = end - start;
    569566
    570567        if (!endptr) {
     
    573570        }
    574571
    575572        if (!direction) {
    576                 memmove(tmp, endptr, 6);
    577                 memmove(startptr + 6, startptr, num * 6);
    578                 memmove(startptr, tmp, 6);
    579                 memmove(tmp2, endptr2, 6);
     573                memmove(tmp, endptr, 3);
     574                memmove(startptr + 3, startptr, num * 3);
     575                memmove(startptr, tmp, 3);
     576                memmove(tmp, endptr2, 6);
    580577                memmove(startptr2 + 6, startptr2, num * 6);
    581                 memmove(startptr2, tmp2, 6);
     578                memmove(startptr2, tmp, 6);
    582579        } else {
    583                 memmove(tmp, startptr, 6);
    584                 memmove(startptr, startptr + 6, num * 6);
    585                 memmove(endptr, tmp, 6);
    586                 memmove(tmp2, startptr2, 6);
     580                memmove(tmp, startptr, 3);
     581                memmove(startptr, startptr + 3, num * 3);
     582                memmove(endptr, tmp, 3);
     583                memmove(tmp, startptr2, 6);
    587584                memmove(startptr2, startptr2 + 6, num * 6);
    588                 memmove(endptr2, tmp2, 6);
     585                memmove(endptr2, tmp, 6);
    589586        }
    590587}
    591588
     
    24612458
    24622459void Scumm::palManipulateInit(int start, int end, int string_id, int time)
    24632460{
     2461        byte *pal, *target, *between;
     2462        byte *string1, *string2, *string3;
     2463        int i;
     2464
    24642465        _palManipStart = start;
    24652466        _palManipEnd = end;
    24662467        _palManipCounter = 0;
    2467 
    2468         byte *startptr = getResourceAddress(rtTemp, 4);
    2469         if (startptr)
    2470                 nukeResource(rtTemp, 4);
    2471         startptr = createResource(rtTemp, 4, 256 * 6);
    2472         if (!startptr) {
    2473                 warning("palManipulateInit(%d,%d,%d,%d): Cannot create rtTemp resource index 4\n", start, end, string_id, time);
    2474                 return;
    2475         }
    2476         startptr += _palManipStart * 6;
    2477 
    2478         byte *endptr = getResourceAddress(rtTemp, 5);
    2479         if (endptr)
    2480                 nukeResource(rtTemp, 5);
    2481         endptr = createResource(rtTemp, 5, 256 * 6);
    2482         if (!endptr) {
    2483                 warning("palManipulateInit(%d,%d,%d,%d): Cannot create rtTemp resource index 5\n", start, end, string_id, time);
    2484                 return;
    2485         }
    2486         endptr += _palManipStart * 6;
    2487 
    2488         byte *curptr = _currentPalette + _palManipStart * 3;
    2489         byte *string1ptr = getStringAddress(string_id) + _palManipStart;
    2490         byte *string2ptr = getStringAddress(string_id + 1) + _palManipStart;
    2491         byte *string3ptr = getStringAddress(string_id + 2) + _palManipStart;
    2492         if (!string1ptr || !string2ptr || !string3ptr) {
     2468       
     2469        if (!_palManipPalette)
     2470                _palManipPalette = (byte *)calloc(0x300, 1);
     2471        if (!_palManipIntermediatePal)
     2472                _palManipIntermediatePal = (byte *)calloc(0x600, 1);
     2473
     2474        pal = _currentPalette + start * 3;
     2475        target = _palManipPalette + start * 3;
     2476        between = _palManipIntermediatePal + start * 6;
     2477
     2478        string1 = getStringAddress(string_id) + start;
     2479        string2 = getStringAddress(string_id + 1) + start;
     2480        string3 = getStringAddress(string_id + 2) + start;
     2481        if (!string1 || !string2 || !string3) {
    24932482                warning("palManipulateInit(%d,%d,%d,%d): Cannot obtain string resources %d, %d and %d\n",
    24942483                        start, end, string_id, time, string_id, string_id + 1, string_id + 2);
    24952484                return;
    24962485        }
    24972486
    2498         int i;
    2499         for (i = _palManipStart; i <= _palManipEnd; ++i) {
    2500                 *((uint16 *)startptr) = ((uint16) *curptr++) << 8;
    2501                 *((uint16 *)endptr) = ((uint16) *string1ptr++) << 8;
    2502                 startptr += 2;
    2503                 endptr += 2;
    2504                 *((uint16 *)startptr) = ((uint16) *curptr++) << 8;
    2505                 *((uint16 *)endptr) = ((uint16) *string2ptr++) << 8;
    2506                 startptr += 2;
    2507                 endptr += 2;
    2508                 *((uint16 *)startptr) = ((uint16) *curptr++) << 8;
    2509                 *((uint16 *)endptr) = ((uint16) *string3ptr++) << 8;
    2510                 startptr += 2;
    2511                 endptr += 2;
     2487        for (i = start; i < end; ++i) {
     2488                *target++ = *string1++;
     2489                *target++ = *string2++;
     2490                *target++ = *string3++;
     2491                *(uint16*)between = ((uint16) *pal++) << 8;
     2492                between += 2;
     2493                *(uint16*)between = ((uint16) *pal++) << 8;
     2494                between += 2;
     2495                *(uint16*)between = ((uint16) *pal++) << 8;
     2496                between += 2;
    25122497        }
    25132498
    25142499        _palManipCounter = time;
     
    25162501
    25172502void Scumm::palManipulate()
    25182503{
    2519         byte *srcptr, *destptr;
    2520         byte *pal;
     2504        byte *target, *pal, *between;
    25212505        int i, j;
    25222506
    2523         if (!_palManipCounter)
    2524                 return;
    2525        
    2526         srcptr = getResourceAddress(rtTemp, 4) + _palManipStart * 6;
    2527         destptr = getResourceAddress(rtTemp, 5) + _palManipStart * 6;
    2528         if (!srcptr || !destptr)
     2507        if (!_palManipCounter || !_palManipPalette || !_palManipIntermediatePal)
    25292508                return;
    25302509       
     2510        target = _palManipPalette + _palManipStart * 3;
    25312511        pal = _currentPalette + _palManipStart * 3;
     2512        between = _palManipIntermediatePal + _palManipStart * 6;
    25322513
    2533         i = _palManipStart;
    2534         while (i < _palManipEnd) {
    2535                 j = (*((uint16 *)srcptr) += (*(uint16 *)destptr - *((uint16 *)srcptr)) / _palManipCounter);
     2514        for (i = _palManipStart; i < _palManipEnd; ++i) {
     2515                j = (*((uint16 *)between) += ((*target++ << 8) - *((uint16 *)between)) / _palManipCounter);
    25362516                *pal++ = j >> 8;
    2537                 srcptr += 2;
    2538                 destptr += 2;
    2539 
    2540                 j = (*((uint16 *)srcptr) += (*(uint16 *)destptr - *((uint16 *)srcptr)) / _palManipCounter);
     2517                between += 2;
     2518                j = (*((uint16 *)between) += ((*target++ << 8) - *((uint16 *)between)) / _palManipCounter);
    25412519                *pal++ = j >> 8;
    2542                 srcptr += 2;
    2543                 destptr += 2;
    2544 
    2545                 j = (*((uint16 *)srcptr) += (*(uint16 *)destptr - *((uint16 *)srcptr)) / _palManipCounter);
     2520                between += 2;
     2521                j = (*((uint16 *)between) += ((*target++ << 8) - *((uint16 *)between)) / _palManipCounter);
    25462522                *pal++ = j >> 8;
    2547                 srcptr += 2;
    2548                 destptr += 2;
    2549 
    2550                 i++;
     2523                between += 2;
    25512524        }
    25522525        setDirtyColors(_palManipStart, _palManipEnd);
    25532526        _palManipCounter--;
    2554         if (!_palManipCounter) {
    2555                 nukeResource(rtTemp, 4);
    2556                 nukeResource(rtTemp, 5);
    2557         }
    25582527}
    25592528
    25602529void Scumm::unkRoomFunc3(int palstart, int palend, int rfact, int gfact, int bfact)
  • scummvm/scumm/resource_v2.cpp

    RCS file: /cvsroot/scummvm/scummvm/scumm/resource_v2.cpp,v
    retrieving revision 1.3
    diff -u -r1.3 resource_v2.cpp
     
    6262
    6363        _shadowPaletteSize = 256;
    6464        _shadowPalette = (byte *) calloc(_shadowPaletteSize, 1);        // FIXME - needs to be removed later
     65
     66        // Jamieson630: palManipulate variable initialization
     67        _palManipCounter = 0;
     68        _palManipPalette = 0; // Will allocate when needed
     69        _palManipIntermediatePal = 0; // Will allocate when needed
     70
    6571        _numFlObject = 50;
    6672        allocateArrays();
    6773
  • scummvm/scumm/resource_v3.cpp

    RCS file: /cvsroot/scummvm/scummvm/scumm/resource_v3.cpp,v
    retrieving revision 1.2
    diff -u -r1.2 resource_v3.cpp
     
    8484
    8585        _shadowPaletteSize = 256;
    8686        _shadowPalette = (byte *) calloc(_shadowPaletteSize, 1);        // stupid for now. Need to be removed later
     87
     88        // Jamieson630: palManipulate variable initialization
     89        _palManipCounter = 0;
     90        _palManipPalette = 0; // Will allocate when needed
     91        _palManipIntermediatePal = 0; // Will allocate when needed
     92
    8793        _numFlObject = 50;
    8894        allocateArrays();
    8995
  • scummvm/scumm/saveload.cpp

    RCS file: /cvsroot/scummvm/scummvm/scumm/saveload.cpp,v
    retrieving revision 1.8
    diff -u -r1.8 saveload.cpp
     
    400400                MKLINE(Scumm, _switchRoomEffect2, sleByte),
    401401                MKLINE(Scumm, _BgNeedsRedraw, sleByte),
    402402
     403                // Jamieson630: variables for palManipulate
     404                // TODO: Add these next time save game format changes.
     405                // MKLINE(Scumm, _palManipStart, sleByte),
     406                // MKLINE(Scumm, _palManipEnd, sleByte),
     407                // MKLINE(Scumm, _palManipCounter, sleUint16),
     408
    403409                MKARRAY(Scumm, gfxUsageBits[0], sleUint32, 200),
    404410                MKLINE(Scumm, gdi._transparency, sleByte),
    405411                MKARRAY(Scumm, _currentPalette[0], sleByte, 768),
     
    505511                MKLINE(Scumm, _switchRoomEffect2, sleByte),
    506512                MKLINE(Scumm, _BgNeedsRedraw, sleByte),
    507513
     514                // Jamieson630: variables for palManipulate
     515                // TODO: Add these next time save game format changes.
     516                // MKLINE(Scumm, _palManipStart, sleByte),
     517                // MKLINE(Scumm, _palManipEnd, sleByte),
     518                // MKLINE(Scumm, _palManipCounter, sleUint16),
     519
    508520                MKARRAY(Scumm, gfxUsageBits[0], sleUint32, 200),
    509521                MKLINE(Scumm, gdi._transparency, sleByte),
    510522                MKARRAY(Scumm, _currentPalette[0], sleByte, 768),
     
    634646
    635647        if (_shadowPaletteSize)
    636648                s->saveLoadArrayOf(_shadowPalette, _shadowPaletteSize, 1, sleByte);
     649
     650        _palManipCounter = 0; // TODO: Remove this once it's being loaded from disk
     651        if (_palManipCounter) {
     652                if (!_palManipPalette)
     653                        _palManipPalette = (byte *)calloc(0x300, 1);
     654                if (!_palManipIntermediatePal)
     655                        _palManipPalette = (byte *)calloc(0x300, 1);
     656                s->saveLoadArrayOf(_palManipPalette, 0x300, 1, sleByte);
     657                s->saveLoadArrayOf(_palManipIntermediatePal, 0x600, 1, sleByte);
     658        }
    637659
    638660        s->saveLoadArrayOf(_classData, _numGlobalObjects, sizeof(_classData[0]), sleUint32);
    639661
  • scummvm/scumm/scumm.h

    RCS file: /cvsroot/scummvm/scummvm/scumm/scumm.h,v
    retrieving revision 1.15
    diff -u -r1.15 scumm.h
     
    851851
    852852        int _drawObjectQueNr;
    853853        byte _drawObjectQue[200];
    854         int16 _palManipStart, _palManipEnd, _palManipCounter;
     854        byte _palManipStart, _palManipEnd;
     855        uint16 _palManipCounter;
     856        byte *_palManipPalette;
     857        byte *_palManipIntermediatePal;
    855858        uint32 gfxUsageBits[200];
    856859        byte *_shadowPalette;
    857860        int _shadowPaletteSize;