Ticket #8598: nut-renderer.diff

File nut-renderer.diff, 7.2 KB (added by eriktorbjorn, 14 years ago)

Patch against current SVN

  • engines/scumm/smush/smush_font.cpp

     
    3030namespace Scumm {
    3131
    3232SmushFont::SmushFont(ScummEngine *vm, const char *filename, bool use_original_colors, bool new_colors) :
    33         NutRenderer(vm, filename, false),
     33        NutRenderer(vm, filename, 8),
    3434        _color(-1),
    3535        _new_colors(new_colors),
    3636        _original(use_original_colors) {
  • engines/scumm/charset.cpp

     
    16211621        if (!_fr[id]) {
    16221622                char fontname[11];
    16231623                sprintf(fontname, "font%d.nut", id);
    1624                 _fr[id] = new NutRenderer(_vm, fontname, true);
     1624                _fr[id] = new NutRenderer(_vm, fontname, 1);
    16251625        }
    16261626        _current = _fr[id];
    16271627        assert(_current);
  • engines/scumm/nut_renderer.cpp

     
    2727
    2828namespace Scumm {
    2929
    30 NutRenderer::NutRenderer(ScummEngine *vm, const char *filename, bool bitmap) :
     30NutRenderer::NutRenderer(ScummEngine *vm, const char *filename, byte bpp) :
    3131        _vm(vm),
    32         _bitmapFont(bitmap),
     32        _bpp(bpp),
    3333        _numChars(0),
    3434        _decodedData(0) {
    3535        memset(_chars, 0, sizeof(_chars));
     
    4040        delete [] _decodedData;
    4141}
    4242
     43void NutRenderer::write2Bits(byte *dst, byte bit, byte val) {
     44        switch (val) {
     45        case 0:         // 00
     46                break;
     47        case 1:         // 01
     48                *dst |= (bit >> 1);
     49                break;
     50        case 224:       // 10
     51                *dst |= bit;
     52                break;
     53        case 225:       // 11
     54                *dst |= (bit | (bit >> 1));
     55                break;
     56        default:
     57                error("NutRenderer::write2Bits: Unexpected value %d\n", val);
     58        }
     59}
     60
     61byte NutRenderer::read2Bits(const byte *src, int offset) {
     62        const byte val[] = { 0, 1, 224, 225 };
     63        byte bits = 0;
     64
     65        const byte *srcPtr = src + (offset / 4);
     66        byte bit = 0x80 >> (2 * (offset % 4));
     67
     68        if (*srcPtr & bit)
     69                bits |= 2;
     70        if (*srcPtr & (bit >> 1))
     71                bits |= 1;
     72
     73        return val[bits];
     74}
     75
    4376void NutRenderer::codec1(byte *dst, const byte *src, int width, int height, int pitch) {
    4477        byte val, code;
    4578        int32 length;
     
    5790                        if (code & 1) {
    5891                                val = *src++;
    5992                                size_line--;
    60                                 if (_bitmapFont) {
    61                                         for (int i = 0; i < length; i++) {
     93                                switch (_bpp) {
     94                                case 1:
     95                                        while (length--) {
    6296                                                if (val)
    6397                                                        *dst |= bit;
    6498                                                bit >>= 1;
     
    67101                                                        dst++;
    68102                                                }
    69103                                        }
    70                                 } else {
     104                                        break;
     105                                case 2:
     106                                        while (length--) {
     107                                                write2Bits(dst, bit, val);
     108                                                bit >>= 2;
     109                                                if (!bit) {
     110                                                        bit = 0x80;
     111                                                        dst++;
     112                                                }
     113                                        }
     114                                        break;
     115                                case 8:
    71116                                        if (val)
    72117                                                memset(dst, val, length);
    73118                                        dst += length;
     119                                        break;
    74120                                }
    75121                        } else {
    76122                                size_line -= length;
    77123                                while (length--) {
    78124                                        val = *src++;
    79                                         if (_bitmapFont) {
     125                                        switch (_bpp) {
     126                                        case 1:
    80127                                                if (val)
    81128                                                        *dst |= bit;
    82129                                                bit >>= 1;
     
    84131                                                        bit = 0x80;
    85132                                                        dst++;
    86133                                                }
    87                                         } else {
     134                                                break;
     135                                        case 2:
     136                                                write2Bits(dst, bit, val);
     137                                                bit >>= 2;
     138                                                if (!bit) {
     139                                                        bit = 0x80;
     140                                                        dst++;
     141                                                }
     142                                                break;
     143                                        case 8:
    88144                                                if (val)
    89145                                                        *dst = val;
    90146                                                dst++;
     147                                                break;
    91148                                        }
    92149                                }
    93150                        }
     
    106163                do {
    107164                        int i;
    108165                        int offs = READ_LE_UINT16(src); src += 2;
    109                         if (_bitmapFont) {
     166                        switch (_bpp) {
     167                        case 1:
     168                        case 2:
    110169                                for (i = 0; i < offs; i++) {
    111                                         bit >>= 1;
     170                                        bit >>= _bpp;
    112171                                        if (!bit) {
    113172                                                bit = 0x80;
    114173                                                dst++;
    115174                                        }
    116175                                }
    117                         } else {
     176                                break;
     177                        case 8:
    118178                                dst += offs;
     179                                break;
    119180                        }
    120181                        len -= offs;
    121182                        if (len <= 0) {
     
    130191                        //  src bytes equal to 255 are replaced by 0 in dst
    131192                        //  src bytes equal to 1 are replaced by a color passed as an argument in the original function
    132193                        //  other src bytes values are copied as-is
    133                         if (_bitmapFont) {
     194                        switch (_bpp) {
     195                        case 1:
    134196                                for (i = 0; i < w; i++) {
    135197                                        if (src[i])
    136198                                                *dst |= bit;
     
    140202                                                dst++;
    141203                                        }
    142204                                }
    143                         } else {
     205                                break;
     206                        case 2:
     207                                for (i = 0; i < w; i++) {
     208                                        write2Bits(dst, bit, src[i]);
     209                                        bit >>= 2;
     210                                        if (!bit) {
     211                                                bit = 0x80;
     212                                                dst++;
     213                                        }
     214                                }
     215                                break;
     216                        case 8:
    144217                                memcpy(dst, src, w);
    145218                                dst += w;
     219                                break;
    146220                        }
    147221                        src += w;
    148222                } while (len > 0);
     
    185259                offset += READ_BE_UINT32(dataSrc + offset + 4) + 16;
    186260                int width = READ_LE_UINT16(dataSrc + offset + 14);
    187261                int height = READ_LE_UINT16(dataSrc + offset + 16);
    188                 if (_bitmapFont) {
    189                         decodedLength += (((width + 7) / 8) * height);
    190                 } else {
    191                         decodedLength += (width * height);
    192                 }
     262                decodedLength += (((_bpp * width + 7) / 8) * height);
    193263        }
    194264
    195265        // If characters have transparency, then bytes just get skipped and
     
    220290                _chars[l].height = READ_LE_UINT16(dataSrc + offset + 16);
    221291                _chars[l].src = decodedPtr;
    222292
    223                 int pitch;
     293                int pitch = (_bpp * _chars[l].width + 7) / 8;
    224294
    225                 if (_bitmapFont) {
    226                         pitch = (_chars[l].width + 7) / 8;
    227                 } else {
    228                         pitch = _chars[l].width;
    229                 }
    230 
    231295                decodedPtr += (pitch * _chars[l].height);
    232296
    233297                const uint8 *fobjptr = dataSrc + offset + 22;
     
    302366}
    303367
    304368void NutRenderer::drawFrame(byte *dst, int c, int x, int y) {
    305         assert(!_bitmapFont);
     369        assert(_bpp == 8);
    306370
    307371        const int width = MIN((int)_chars[c].width, _vm->_screenWidth - x);
    308372        const int height = MIN((int)_chars[c].height, _vm->_screenHeight - y);
     
    342406        const byte *src = _chars[c].src;
    343407        int srcPitch;
    344408
    345         if (_bitmapFont) {
    346                 srcPitch = (_chars[c].width + 7) / 8;
    347         } else {
    348                 srcPitch = _chars[c].width;
    349         }
     409        srcPitch = (_bpp * _chars[c].width + 7) / 8;
    350410
    351411        const int minX = x < 0 ? -x : 0;
    352412        const int minY = y < 0 ? -y : 0;
     
    364424                int tx;
    365425
    366426                for (tx = minX; tx < width; tx++) {
    367                         if (_bitmapFont) {
     427                        switch (_bpp) {
     428                        case 1:
    368429                                if (src[tx / 8] & (0x80 >> (tx % 8))) {
    369430                                        dst[tx] = color;
    370431                                }
    371                         } else {
     432                                break;
     433                        case 2:
     434                                if (read2Bits(src, tx)) {
     435                                        dst[tx] = color;
     436                                }
     437                                break;
     438                        case 8:
    372439                                if (src[tx] != 0) {
    373440                                        dst[tx] = color;
    374441                                }
     442                                break;
    375443                        }
    376444                }
    377445                src += srcPitch;
  • engines/scumm/nut_renderer.h

     
    3232class NutRenderer {
    3333protected:
    3434        ScummEngine *_vm;
    35         bool _bitmapFont;
     35        byte _bpp;
    3636        int _numChars;
    3737        byte *_decodedData;
    3838        struct {
     
    4141                byte *src;
    4242        } _chars[256];
    4343
     44        void write2Bits(byte *dst, byte bit, byte val);
     45        byte read2Bits(const byte *src, int offset);
     46
    4447        void codec1(byte *dst, const byte *src, int width, int height, int pitch);
    4548        void codec21(byte *dst, const byte *src, int width, int height, int pitch);
    4649
     
    5053        void loadFont(const char *filename);
    5154
    5255public:
    53         NutRenderer(ScummEngine *vm, const char *filename, bool bitmap);
     56        NutRenderer(ScummEngine *vm, const char *filename, byte bpp);
    5457        virtual ~NutRenderer();
    5558        int getNumChars() const { return _numChars; }
    5659