// Replace this function with something useful.
void draw_bitmap(ANT_Bitmap bitmap, int x, int y)
{
int i, j, p, q;
int x_max = x + bitmap.width;
int y_max = y + bitmap.rows;
byte[] bitmap_buffer = bitmap.buffer;
int bitmap_width = bitmap.width;
for (i = x, p = 0; i < x_max; i++, p++)
{
for (j = y, q = 0; j < y_max; j++, q++)
{
if (i < 0 ||
j < 0 ||
i >= WIDTH ||
j >= HEIGHT)
{
continue;
}
image[j, i] |= bitmap_buffer[q * bitmap_width + p];
}
}
}
public void DrawToBitmap(byte[] pData, int texWidth, int texHeight)
{
if (IsEmpty())
{
return;
}
// Convert The Glyph To A Bitmap.
ANT_Error error = ANT.ANT_Glyph_To_Bitmap(ref m_pGlyph, ANT_Render_Mode.ANT_RENDER_MODE_NORMAL, null, true);
if (error == ANT_Error.ANT_Err_Ok)
{
ANT_BitmapGlyph bitmap_glyph = (ANT_BitmapGlyph)m_pGlyph;
// This Reference Will Make Accessing The Bitmap Easier.
ANT_Bitmap bitmap = bitmap_glyph.bitmap;
int x, y = 0;
int index;
for (y = 0; y < bitmap.rows; y++)
{
for (x = 0; x < bitmap.width; x++)
{
index = (m_y + y) * texWidth + m_x + x;
pData[index] = bitmap.buffer[y * bitmap.width + x];
}
}
}
}
public static Bitmap ToBitmap(ANT_Bitmap bitmap, bool flipY)
{
if (bitmap == null)
{
return(null);
}
byte[] buf = bitmap.buffer;
if (buf == null ||
buf.Length == 0)
{
return(null);
}
int buf_index = 0;
int pitch = bitmap.pitch;
//NoNeed int bpitch = pitch;
if (!flipY)
{
buf_index += bitmap.pitch * (bitmap.rows - 1);
pitch = -pitch;
}
int bitmap_rows = bitmap.rows;
int bitmap_width = bitmap.width;
bitset_iterator bits = new bitset_iterator(bitmap.buffer, buf_index);
Bitmap result = new Bitmap(bitmap_width, bitmap_rows, PixelFormat.Format32bppArgb);
BitmapData bitmapData = result.LockBits(ImageLockMode.WriteOnly);
byte[] resultData = bitmapData.Scan0;
int resultStride = bitmapData.Stride;
int resultBpp = result.ByteDepth;
int y = 3;
int i, x;
switch (bitmap.pixel_mode)
{
case ANT_Pixel_Mode.ANT_PIXEL_MODE_MONO:
{
for (i = 0; i < bitmap_rows; i++, y += resultStride, buf_index += pitch)
{
bits.Reset(buf_index);
for (x = 0; x < bitmap_width; x++)
{
if (bits.bit())
{
resultData[y + x * resultBpp] = cover_full;
}
bits.Inc();
}
}
}
break;
case ANT_Pixel_Mode.ANT_PIXEL_MODE_GRAY:
case ANT_Pixel_Mode.ANT_PIXEL_MODE_LCD:
case ANT_Pixel_Mode.ANT_PIXEL_MODE_LCD_V:
{
for (i = 0; i < bitmap_rows; i++, y += resultStride, buf_index += pitch)
{
int p_index = buf_index;
for (x = 0; x < bitmap_width; x++, p_index++)
{
if (buf[p_index] != 0)
{
resultData[y + x * resultBpp] = //ras.apply_gamma(buf[p_index]);
buf[p_index];
}
}
}
}
break;
case ANT_Pixel_Mode.ANT_PIXEL_MODE_GRAY2:
{
for (i = 0; i < bitmap_rows; i++, y += resultStride, buf_index += pitch)
{
int p_index = buf_index;
for (x = 0; x < bitmap_width; x++)
{
byte b = 0;
switch (x % 4)
{
case 0:
{
b = (byte)((buf[p_index] & 0x3) * 85);
break;
}
case 1:
{
b = (byte)(((buf[p_index] & 0xC) >> 2) * 85);
break;
}
case 2:
{
b = (byte)(((buf[p_index] & 0x30) >> 4) * 85);
break;
}
case 3:
{
b = (byte)(((buf[p_index] & 0xC0) >> 6) * 85);
p_index++;
break;
}
}
if (b != 0)
{
resultData[y + x * resultBpp] = //ras.apply_gamma(buf[p_index]);
b;
}
}
}
}
break;
case ANT_Pixel_Mode.ANT_PIXEL_MODE_GRAY4:
{
for (i = 0; i < bitmap_rows; i++, y += resultStride, buf_index += pitch)
{
int p_index = buf_index;
for (x = 0; x < bitmap_width; x++)
{
byte b = 0;
switch (x % 2)
{
case 0:
{
b = (byte)((buf[p_index] & 0x0F) * 17);
break;
}
case 1:
{
b = (byte)(((buf[p_index] & 0xF0) >> 4) * 17);
p_index++;
break;
}
}
if (b != 0)
{
resultData[y + x * resultBpp] = //ras.apply_gamma(buf[p_index]);
b;
}
}
}
}
break;
default:
{
//ANT_Pixel_Mode pm = bitmap.pixel_mode;
}
break;
}
result.UnlockBits(bitmapData);
return(result);
}
public static Bitmap ToBitmap(ANT_Bitmap bitmap)
{
return(ToBitmap(bitmap, false));
}
