Ticket #8240: 2byte_charset.2.diff

scumm/charset.cpp

@@ -23 +23 @@
 #include "scumm.h"
 #include "nut_renderer.h"
 
+bool _2byte_pos_hack;
+
+int get2byteIndex(int idx)
+{
+        /*
+                switch(language)
+                case korean:
+                        return ( (idx % 256) - 0xb0) * 94 + (idx / 256) - 0xa1;
+                case japanese:
+                        ...
+                case taiwan:
+                        ...
+        */
+        return ( (idx % 256) - 0xb0) * 94 + (idx / 256) - 0xa1; // only for korean
+}
+
+bool Scumm::checkCJKLanguage()
+{
+        return (_language == KO_KOR || _language == JA_JPN || _language == ZH_TWN);
+}
+
 CharsetRenderer::CharsetRenderer(Scumm *vm) {
 
         _nextLeft = 0;
@@ -79 +100 @@
 
 // do spacing for variable width old-style font
 int CharsetRendererClassic::getCharWidth(byte chr) {
+        if(chr >= 0x80 && _CJKMode)
+                return 6;
         int spacing = 0;
 
         int offs = READ_LE_UINT32(_fontPtr + chr * 4 + 4);
@@ -628 +651 @@
         int offsX, offsY;
         int d;
         VirtScreen *vs;
+        int is2byte = 0;
 
         _vm->checkRange(_vm->_maxCharsets - 1, 1, _curId, "Printing with bad charset %d");
         
@@ -640 +664 @@
         _bpp = *_fontPtr;
         _vm->_charsetColorMap[1] = _color;
 
-        uint32 charOffs = READ_LE_UINT32(_fontPtr + chr * 4 + 4);
+        is2byte = (chr >= 0x80 && _CJKMode) ? 1 : 0;
+
+        uint32 charOffs = READ_LE_UINT32(_fontPtr + (is2byte ? 0x0f : chr) * 4 + 4); //HACK!
 
         if (!charOffs)
                 return;
@@ -649 +675 @@
 
         _charPtr = _fontPtr + charOffs;
 
-        width = _charPtr[0];
+        if(is2byte) width = _charPtr[0] - 1; else width = _charPtr[0]; //HACK!!!
         height = _charPtr[1];
         if (_firstChar) {
                 _str.left = 0;
@@ -714 +740 @@
         byte *mask = _vm->getMaskBuffer(_left, drawTop, 0);
         byte *dst = vs->screenPtr + vs->xstart + drawTop * _vm->_screenWidth + _left;
 
+        byte *back = dst;
         if (_blitAlso) {
-                byte *back = dst;
                 dst = _vm->getResourceAddress(rtBuffer, vs->number + 5)
                         + vs->xstart + drawTop * _vm->_screenWidth + _left;
+        }
 
+        if(is2byte) {
+                width = _2byte_width;
+                height = _2byte_height;
+                _charPtr = (byte *)&_2byte[get2byteIndex(chr) * 18];
+                _bpp = 1;
+                draw2byte(vs, dst, mask, drawTop, width, height);
+//              drawBits(vs, dst, mask, drawTop, width, height);
+        } else
                 drawBits(vs, dst, mask, drawTop, width, height);
 
+        if (_blitAlso) {
                 int h = height;
                 do {
                         memcpy(back, dst, width);
                         back += _vm->_screenWidth;
                         dst += _vm->_screenWidth;
                 } while (--h);
-        } else {
-                drawBits(vs, dst, mask, drawTop, width, height);
         }
         
         _left += width;
@@ -752 +786 @@
         bits = *_charPtr++;
         numbits = 8;
 
-        y = 0;
-
         for (y = 0; y < height && y + drawTop < vs->height; y++) {
                 maskmask = revBitMask[_left & 7];
                 maskpos = 0;
@@ -785 +817 @@
         }
 }
 
+void CharsetRendererClassic::draw2byte(VirtScreen *vs, byte *dst, byte *mask, int drawTop, int width, int height) {
+        byte maskmask;
+        int y, x;
+        int maskpos;
+        //int color;
+        byte numbits, bits;
+        bool useMask = (vs->number == 0 && !_ignoreCharsetMask);
+
+        bits = *_charPtr++;
+        numbits = 8;
+
+        for (y = 0; y < height && y + drawTop < vs->height; y++) {
+                maskmask = revBitMask[_left & 7];
+                maskpos = 0;
+
+                for (x = 0; x < width; x++) {
+                        if(x && ((x % 8) == 0))
+                                bits = *_charPtr++;
+                        if (bits & revBitMask[x % 8]) {
+                                *(dst + x + 1) = _vm->_charsetColorMap[0];
+                                *(dst + x    ) = _vm->_charsetColorMap[1]; //FIXME?
+                                if (useMask) {
+                                        mask[maskpos] |= maskmask;
+                                        if (maskmask == 1) {
+                                                mask[maskpos + 1] |= 0x80;
+                                        } else {
+                                                mask[maskpos] |= (maskmask >> 1);
+                                        }
+                                }
+                        }
+                        maskmask >>= 1;
+                        if (maskmask == 0) {
+                                maskmask = 0x80;
+                                maskpos++;
+                        }
+                }
+
+                bits = *_charPtr++;
+                dst += _vm->_screenWidth;
+                mask += _vm->gdi._numStrips;
+        }
+}
+
 CharsetRendererNut::CharsetRendererNut(Scumm *vm)
          : CharsetRenderer(vm) {
         _current = 0;
@@ -839 +914 @@
         int width = _current->getCharWidth(chr);
         int height = _current->getCharHeight(chr);
 
+        if(chr >= 256 && _CJKMode)
+                width = 16;
+
         _hasMask = true;
-        _current->drawChar((char)chr, _left, _top, _color, !_ignoreCharsetMask);
+        if(chr >= 256 && _CJKMode)
+                _current->draw2byte(chr, _left, _top + (_2byte_pos_hack ? 6 : 0), _color, !_ignoreCharsetMask);
+        else
+                _current->drawChar((char)chr, _left, _top, _color, !_ignoreCharsetMask);
         _vm->updateDirtyRect(0, _left, _left + width, _top, _top + height, 0);
 
         _left += width;
@@ -849 +930 @@
 
         if (_top + height > _str.bottom)
                 _str.bottom = _top + height;
+
+        _2byte_pos_hack = false;
 }
 

scumm/charset.h

@@ -90 +90 @@
         byte *_charPtr;
 
         int getCharWidth(byte chr);
+        void draw2byte(VirtScreen *vs, byte *dst, byte *mask, int drawTop, int width, int height);
         void drawBits(VirtScreen *vs, byte *dst, byte *mask, int drawTop, int width, int height);
 
 public:

scumm/nut_renderer.cpp

@@ -22 +22 @@
 #include "scumm.h"
 #include "nut_renderer.h"
 
+extern int get2byteIndex(int idx);
+
+
 NutRenderer::NutRenderer(Scumm *vm) {
         _vm = vm;
         _initialized = false;
@@ -133 +136 @@
                 return 0;
         }
 
-        return READ_LE_UINT16(_dataSrc + _offsets[c] + 6);
+        if(c & 0x80 && _CJKMode)
+                return 8;
+        else
+                return READ_LE_UINT16(_dataSrc + _offsets[c] + 6) + 2;
 }
 
 int32 NutRenderer::getCharHeight(byte c) {
@@ -143 +149 @@
                 return 0;
         }
 
-        return READ_LE_UINT16(_dataSrc + _offsets[c] + 8);
+        if(c & 0x80 && _CJKMode)
+                return 16;
+        else
+                return READ_LE_UINT16(_dataSrc + _offsets[c] + 8);
 }
 
 int32 NutRenderer::getStringWidth(const byte *string) {
@@ -237 +246 @@
         
                 x -= offsetX[i];
                 y -= offsetY[i];
+        }
+}
+
+void NutRenderer::draw2byte(int c, int32 x, int32 y, byte color, bool useMask) {
+        if (_loaded == false) {
+                debug(2, "NutRenderer::draw2byte() Font is not loaded");
+                return;
+        }
+
+        int _2byteIndex = get2byteIndex(c);
+        int width = _2byte_width;
+        int height = _2byte_height;
+        char *_2bPtr = &_2byte[_2byteIndex * (_2byte_height * 2)];
+
+        byte *dst, *mask = NULL;
+        byte maskmask;
+        int maskpos;
+        
+        dst = _vm->virtscr[0].screenPtr + y * _vm->_screenWidth + x + _vm->virtscr[0].xstart;
+        mask = _vm->getResourceAddress(rtBuffer, 9)
+                                        + (y * _vm->_screenWidth + x) / 8 + _vm->_screenStartStrip;
+
+        for (int ty = 0; ty < height; ty++) {
+                maskmask = revBitMask[x & 7];
+                maskpos = 0;
+                for (int tx = 0; tx < width; tx++) {
+                        if (x + tx < 0 || x + tx >= _vm->_screenWidth || y + ty < 0 || y + ty >= _vm->_screenHeight)
+                                continue;
+                        if(tx && ((tx % 8) == 0))
+                                _2bPtr++;
+                        if (*_2bPtr & revBitMask[tx % 8]) {
+                                *(dst + tx + 1) = 0;
+                                *(dst + tx) = color;
+                                if (useMask) {
+                                        mask[maskpos] |= maskmask;
+                                        if (maskmask == 1) {
+                                                mask[maskpos + 1] |= 0x80;
+                                        } else {
+                                                mask[maskpos] |= (maskmask >> 1);
+                                        }
+                                }
+                        }
+
+                        maskmask >>= 1;
+                        if (maskmask == 0) {
+                                maskmask = 0x80;
+                                maskpos++;
+                        }
+                }
+
+                _2bPtr++;
+                dst += _vm->_screenWidth;
+                mask += _vm->gdi._numStrips;
         }
 }

scumm/nut_renderer.h

@@ -41 +41 @@
         ~NutRenderer();
 
         bool loadFont(const char *filename, const char *dir);
+        void draw2byte(int c, int32 x, int32 y, byte color, bool useMask);
         void drawChar(byte c, int32 x, int32 y, byte color, bool useMask);
 //      void drawString(const char *string, int32 x, int32 y, byte color, int32 mode);
         int32 getCharWidth(byte c);

scumm/scumm.h

@@ -1064 +1064 @@
 
         void loadLanguageBundle();
 public:
+        bool checkCJKLanguage();
         void translateText(const byte *text, byte *trans_buff); // Used by class ScummDialog
 protected:
 
@@ -1197 +1198 @@
 
 // This is a constant lookup table of reverse bit masks
 extern const byte revBitMask[8];
+
+//nasty hacks
+extern bool _CJKMode;
+extern int _gid;
+extern char *_2byte;
+extern int _2byte_height;
+extern int _2byte_width;
+extern bool _2byte_pos_hack;
 
 /* Direction conversion functions (between old dir and new dir format) */
 int newDirToOldDir(int dir);

scumm/scummvm.cpp

@@ -56 +56 @@
 Scumm *g_scumm = 0;
 ScummDebugger *g_debugger;
 
+int _gid;
+char *_2byte;
+int _2byte_width;
+int _2byte_height;
+bool _CJKMode;
+
 extern NewGui *g_gui;
 extern uint16 _debugLevel;
 
@@ -636 +642 @@
                 _saveLoadCompatible = false;
         }
         loadLanguageBundle();
+
+        // Load CJK font
+        if((_gameId == GID_DIG || _gameId == GID_CMI) && checkCJKLanguage()) {
+                _gid = _gameId;
+                File fp;
+                const char *fontFile = NULL;
+                _CJKMode = false;
+                switch(_language) {
+                case KO_KOR:
+                        _CJKMode = true;
+                        fontFile = "korean.fnt";
+                        break;
+                case JA_JPN:
+                        _CJKMode = true;
+                        fontFile = (_gameId == GID_DIG) ? "kanji16.fnt" : "japanese.fnt";
+                        break;
+                case ZH_TWN:
+                        if(_gameId == GID_CMI) {
+                                _CJKMode = true;
+                                fontFile = "chinese.fnt";
+                        }
+                        break;
+                }
+                if(_CJKMode && fp.open(fontFile, getGameDataPath(), 1)) {
+                        debug(2, "Loading CJK Font");
+                        fp.seek(2,SEEK_CUR);
+                        _2byte_width = fp.readByte(); //FIXME: is this correct?
+                        _2byte_height = fp.readByte();
+
+                        int numChar = 0;
+                        switch(_language) {
+                        case KO_KOR:
+                                numChar = 2350;
+                                break;
+                        case JA_JPN:
+                                numChar = (_gameId == GID_DIG) ? 1 : 1; //FIXME
+                                break;
+                        case ZH_TWN:
+                                numChar = 1; //FIXME
+                                break;
+                        }
+                        _2byte = new char[2 * _2byte_height * numChar];
+                        fp.read(_2byte, 2 * _2byte_height * numChar);
+                        fp.close();
+                }
+        }
+
         _audioNames = NULL;
 }
 
@@ -643 +696 @@
 {
         delete [] _actors;
         
+        delete _2byte;
         delete _charset;
         delete _pauseDialog;
         delete _optionsDialog;

scumm/string.cpp

@@ -242 +242 @@
                 if (c != 0xFF) {
                         _charset->_left = _charset->_nextLeft;
                         _charset->_top = _charset->_nextTop;
+                        if(c & 0x80 && _CJKMode) {
+                                c += *buffer++ * 256;
+                                if(_gameId == GID_CMI)
+                                        _2byte_pos_hack = true; //HACK: ¿µ¹®°úÀÇ yÁÂÇ¥°¡ ¸ÂÁö ¾Ê´Ù.
+                        }
                         if (_features & GF_AFTER_V2 || _features & GF_AFTER_V3) {
                                 _charset->printChar(c);
                         } else if (_features & GF_AFTER_V6) {
@@ -429 +434 @@
                                 if (_string[a].no_talk_anim == 0)
                                         _charset->_blitAlso = true;
                         }
-                        _charset->printChar(chr);
+                        if(chr >= 0x80 && _CJKMode) {
+                                if(_gameId == GID_CMI)
+                                        _2byte_pos_hack = true;
+                                _charset->printChar(chr + (buf[i++] * 256));
+                        }
+                        else
+                                _charset->printChar(chr);
                         _charset->_blitAlso = false;
                 }
         }
@@ -731 +742 @@
                         if (c != 0 && c != 0xFF) {
                                 _charset->_left = _charset->_nextLeft;
                                 _charset->_top = _charset->_nextTop;
-                                _charset->printChar(c);
+                                if(c >= 0x80 && _CJKMode)
+                                        _charset->printChar(c + (*buf++ * 256));
+                                else
+                                        _charset->printChar(c);
                                 _charset->_nextLeft = _charset->_left;
                                 _charset->_nextTop = _charset->_top;
                         }

scumm/smush/smush_font.cpp

@@ -27 +27 @@
 
 #include "smush_font.h"
 
+extern int get2byteIndex(int idx);
+
 SmushFont::SmushFont(bool use_original_colors, bool new_colors) :
         _nbChars(0),
         _color(-1),
@@ -105 +107 @@
 }
 
 int SmushFont::getCharWidth(byte v) {
+        if(v >= 0x80 && _CJKMode)
+                return get2byteCharWidth();
+
         if(v >= _nbChars)
                 error("invalid character in SmushFont::charWidth : %d (%d)", v, _nbChars);
 
@@ -112 +117 @@
 }
 
 int SmushFont::getCharHeight(byte v) {
+        if(v >= 0x80 && _CJKMode)
+                return get2byteCharHeight();
+
         if(v >= _nbChars)
                 error("invalid character in SmushFont::charHeight : %d (%d)", v, _nbChars);
 
@@ -219 +227 @@
         return w;
 }
 
+int SmushFont::get2byteCharWidth() {
+        if(_gid == GID_CMI)
+                return 8;
+        if(_gid == GID_DIG)
+                return 6;
+        return 0;
+}
+int SmushFont::get2byteCharHeight() {
+        if(_gid == GID_CMI)
+                return 16;
+        if(_gid == GID_DIG)
+                return 10;
+        return 0;
+}
+
+int SmushFont::draw2byte(byte *buffer, int dst_width, int x, int y, byte fst, byte snd) {
+        int w = _2byte_width;
+        int h = _2byte_height;
+
+        int _2byteIndex = get2byteIndex(fst + (snd * 256));
+        char *_2bytePtr = &_2byte[_2byteIndex * (_2byte_height * 2)];
+        char *pData = _2bytePtr;
+        byte *dst = buffer + dst_width * (y + (_gid == GID_CMI ? 7 : 2)) + x;
+
+        if(_original) {
+                for(int32 j = 0; j < h; j++) {
+                        for(int32 i = 0; i < w; i++) {
+                                char value = 1;//*src++;
+                                if(value) dst[i] = value;
+                        }
+                        dst += dst_width;
+                }
+        } else {
+                char color = (_color != -1) ? _color : 1;
+                if (_new_colors == true) {
+                        for(int j = 0; j < h; j++) {
+                                for(int i = 0; i < w; i++) {
+                                        if(i && ((i % 8) == 0))
+                                                pData++;
+                                        if (*pData & revBitMask[i % 8]) {
+                                                dst[i + 1] = 0;
+                                                dst[i] = 0xff; //FIXME
+                                        }
+                                }
+                                pData++;
+                                dst += dst_width;
+                        }
+                } else {
+                        for(int j = 0; j < h; j++) {
+                                for(int i = 0; i < w; i++) {
+                                        if(i && ((i % 8) == 0))
+                                                pData++;
+                                        if (*pData & revBitMask[i % 8]) {
+                                                dst[i + 1] = 0;
+                                                dst[i] = color;
+                                        }
+                                }
+                                pData++;
+                                dst += dst_width;
+                        }
+                }
+        }
+        return w + 1;
+}
+
 static char **split(char *str, char sep) {
         char **ret = new char *[62];
         int n = 0;
@@ -243 +316 @@
 }
 
 void SmushFont::drawSubstring(char *str, byte *buffer, int dst_width, int x, int y) {
-        for(int i = 0; str[i] != 0; i++)
-                x += drawChar(buffer, dst_width, x, y, str[i]);
+        for(int i = 0; str[i] != 0; i++) {
+                if((byte)str[i] >= 0x80 && _CJKMode) {
+                        x += draw2byte(buffer, dst_width, x, y, str[i], str[i+1]);
+                        i++;
+                } else
+                        x += drawChar(buffer, dst_width, x, y, str[i]);
+        }
 }
 
 void SmushFont::drawStringAbsolute(char *str, byte *buffer, int dst_width, int x, int y) {

scumm/smush/smush_font.h

@@ -46 +46 @@
 
 protected:
 
+        int get2byteCharWidth();
+        int get2byteCharHeight();
         int getCharWidth(byte c);
         int getStringWidth(char *str);
         int getCharHeight(byte c);
         int getStringHeight(char *str);
+        int draw2byte(byte *buffer, int dst_width, int x, int y, byte fst, byte snd);
         int drawChar(byte *buffer, int dst_width, int x, int y, byte chr);
         void drawSubstring(char *str, byte *buffer, int dst_width, int x, int y);
         void decodeCodec(byte *dst, byte *src, int length);