Supporting Double-Byte character

struct CharInfo {
      S16 bitmapIndex;    // Note: -1 indicates character is NOT to be
                          //  rendered, i.e., \n, \r, etc.
      U16  xOffset;        // x offset into bitmap sheet
      U16  yOffset;        // y offset into bitmap sheet
      U16  width;          // width of character (pixels)
      U16  height;         // height of character (pixels)
      S16  xOrigin;
      S16  yOrigin;
      S16  xIncrement;
      U8  *bitmapData;    // temp storage for bitmap data	
   };

S16             mRemapTable[65536];    // - Index remapping

Quote:
Puzzled!!!
could tell me the exactly position where these code added in the winfont.cc?

for(S32 i = 32; i < 256; i++)
	{
	   if(GetGlyphOutline(
	      fontHDC,					// handle of device context 
	      i,							// character to query 
	      GGO_GRAY8_BITMAP,		// format of data to return 
	      &metrics,				// address of structure for metrics 
	      sizeof(scratchPad),	// size of buffer for data 
	      scratchPad,				// address of buffer for data 
	      &matrix 					// address of transformation matrix structure  
	      ) != GDI_ERROR)
	   {
	      glyphCount++;
	      U32 rowStride = (metrics.gmBlackBoxX + 3) & ~3; // DWORD aligned
	  	   U32 size = rowStride * metrics.gmBlackBoxY;
	      for(U32 j = 0; j < size; j++)
	      {
	         U32 pad = U32(scratchPad[j]) << 2;
	         if(pad > 255)
	            pad = 255;
	         scratchPad[j] = pad;
	      }
	      S32 inc = metrics.gmCellIncX;
	      if(inc < 0)
	         inc = -inc;
	      retFont->insertBitmap(i, scratchPad, rowStride, metrics.gmBlackBoxX, metrics.gmBlackBoxY, metrics.gmptGlyphOrigin.x, metrics.gmptGlyphOrigin.y, metrics.gmCellIncX);
	   }
	   else
	   {
	      char b = i;
	      SIZE size;
	      GetTextExtentPoint32(fontHDC, &b, 1, &size);
	      if(size.cx)
	         retFont->insertBitmap(i, scratchPad, 0, 0, 0, 0, 0, size.cx);
	   }
	}

retFont->pack(textMetric.tmHeight, textMetric.tmAscent);

Point2I curSheetSize(256, 256);

Point2I curSheetSize(2048, 2048);

for (c = *str; str < endStr; c = *(++str))
......

U16          c;

while (str < endStr)
   {
		if(IsDBCSLeadByte(*str))
		{
			c = ((*str)<<8) | (*(str+1));
			str+=2;
		}
		else
		{
			c = *str++;
		
			// We have to do a little dance here since \t = 0x9, \n = 0xa, and \r = 0xd
			if ((c >=  1 && c <=  7) ||
				(c >= 11 && c <= 12) ||
				(c == 14)) 
			{
				// Color code
				if (colorTable) 
				{
					static U8 remap[15] = 
					{ 
						0x0,
						0x0, 
						0x1, 
						0x2, 
						0x3, 
						0x4, 
						0x5, 
						0x6, 
						0x0, 
						0x0,
						0x0, 
						0x7, 
						0x8,
						0x0,
						0x9 
					};

					U8 remapped = remap[c];
					// Ignore if the color is greater than the specified max index:
					if ( remapped <= maxColorIndex )
					{
						const ColorI &clr = colorTable[remapped];
						currentColor = sg_bitmapModulation = clr;
					}
				}
				continue;
			}
			// reset color?
			if ( c == 15 )
			{
				currentColor = sg_textAnchorColor;
				sg_bitmapModulation = sg_textAnchorColor;
				continue;
			}

			// push color:
			if ( c == 16 )
			{
				sg_stackColor = sg_bitmapModulation;
				continue;
			}

			// pop color:
			if ( c == 17 )
			{
				currentColor = sg_stackColor;
				sg_bitmapModulation = sg_stackColor;
				continue;
			}
		}

      // Tab character
      if( !font->isValidChar( c ) ) 
      {
         if ( c == '\t' ) 
         {
            const GFont::CharInfo &ci = font->getCharInfo( ' ' );
            pt.x += ci.xIncrement * GFont::TabWidthInSpaces;
         }
         continue;
      }

      const GFont::CharInfo &ci = font->getCharInfo(c);
      TextureObject *newObj = font->getTextureHandle(ci.bitmapIndex);
      if(newObj != lastTexture)
      {
         if(currentPt)
         {
            glBindTexture(GL_TEXTURE_2D, lastTexture->texGLName);
            glDrawArrays( GL_QUADS, 0, currentPt );
            currentPt = 0;
         }
         lastTexture = newObj;
      }
      if(ci.width != 0 && ci.height != 0)
      {
         pt.y = ptDraw.y + font->getBaseline() - ci.yOrigin;
         pt.x += ci.xOrigin;
         
         F32 texLeft   = F32(ci.xOffset)             / F32(lastTexture->texWidth);
         F32 texRight  = F32(ci.xOffset + ci.width)  / F32(lastTexture->texWidth);
         F32 texTop    = F32(ci.yOffset)             / F32(lastTexture->texHeight);
         F32 texBottom = F32(ci.yOffset + ci.height) / F32(lastTexture->texHeight);

         F32 screenLeft   = pt.x;
         F32 screenRight  = pt.x + ci.width;
         F32 screenTop    = pt.y;
         F32 screenBottom = pt.y + ci.height;

         vert[currentPt++].set(screenLeft, screenBottom, texLeft, texBottom, currentColor);
         vert[currentPt++].set(screenRight, screenBottom, texRight, texBottom, currentColor);
         vert[currentPt++].set(screenRight, screenTop, texRight, texTop, currentColor);
         vert[currentPt++].set(screenLeft, screenTop, texLeft, texTop, currentColor);

         pt.x += ci.xIncrement - ci.xOrigin;
      }
      else
         pt.x += ci.xIncrement;
   }

#include <windows.h>

for(i = 0; i < 256; i++)
      io_rStream.read(&mRemapTable[i]);

for(i = 0; i < 256; i++)
      stream.write(mRemapTable[i]);

for(i = 0; i < 65536; i++)
      io_rStream.read(&mRemapTable[i]);

for(i = 0; i < 65536; i++)
      stream.write(mRemapTable[i]);