public Kh2MessageRenderer(
ISpriteDrawing drawing,
RenderingMessageContext context)
{
_drawing = drawing;
_msgContext = context;
_fontSpacing = context.FontSpacing;
_iconSpacing = context.IconSpacing;
_imageFont = context.Font;
_imageFont2 = context.Font2;
_imageIcon = context.Icon;
_charPerRow = context.Font?.Size.Width / context.FontWidth ?? 1;
_iconPerRow = context.Icon?.Size.Width / IconWidth ?? 1;
_tableHeight = context.TableHeight;
_charTableHeight = context.TableHeight / context.FontHeight * context.FontHeight;
_encode = context.Encoder;
if (_imageFont != null)
{
InitializeSurface(ref _spriteFont, _imageFont);
}
if (_imageFont2 != null)
{
InitializeSurface(ref _spriteFont2, _imageFont2);
}
if (_imageIcon != null)
{
InitializeSurface(ref _spriteIcon, _imageIcon);
}
}
private static byte[] GetDataResource4bpp(IImageRead image)
{
var size = image.Size;
var data = image.GetData();
var clut = image.GetClut();
var dstData = new byte[size.Width * size.Height * sizeof(uint)];
var srcIndex = 0;
var dstIndex = 0;
for (var y = 0; y < size.Height; y++)
{
for (var i = 0; i < size.Width / 2; i++)
{
var ch = data[srcIndex++];
var palIndex1 = (ch >> 4);
var palIndex2 = (ch & 15);
dstData[dstIndex++] = clut[palIndex1 * 4 + 2];
dstData[dstIndex++] = clut[palIndex1 * 4 + 1];
dstData[dstIndex++] = clut[palIndex1 * 4 + 0];
dstData[dstIndex++] = clut[palIndex1 * 4 + 3];
dstData[dstIndex++] = clut[palIndex2 * 4 + 2];
dstData[dstIndex++] = clut[palIndex2 * 4 + 1];
dstData[dstIndex++] = clut[palIndex2 * 4 + 0];
dstData[dstIndex++] = clut[palIndex2 * 4 + 3];
}
}
return(dstData);
}
public static void SaveImage(this IImageRead imageRead, string fileName)
{
using (var gdiBitmap = imageRead.CreateBitmap())
{
gdiBitmap.Save(fileName);
}
}
private static byte[] From4bpp(this IImageRead image, byte[] channelOrder)
{
var size = image.Size;
var data = image.GetData();
var clut = image.GetClut();
var dstData = new byte[size.Width * size.Height * sizeof(uint)];
var srcIndex = 0;
var dstIndex = 0;
for (var y = 0; y < size.Height; y++)
{
for (var i = 0; i < size.Width / 2; i++)
{
var ch = data[srcIndex++];
var palIndex1 = (ch & 15);
var palIndex2 = (ch >> 4);
dstData[dstIndex++] = clut[palIndex1 * 4 + channelOrder[0]];
dstData[dstIndex++] = clut[palIndex1 * 4 + channelOrder[1]];
dstData[dstIndex++] = clut[palIndex1 * 4 + channelOrder[2]];
dstData[dstIndex++] = clut[palIndex1 * 4 + channelOrder[3]];
dstData[dstIndex++] = clut[palIndex2 * 4 + channelOrder[0]];
dstData[dstIndex++] = clut[palIndex2 * 4 + channelOrder[1]];
dstData[dstIndex++] = clut[palIndex2 * 4 + channelOrder[2]];
dstData[dstIndex++] = clut[palIndex2 * 4 + channelOrder[3]];
}
}
return(dstData);
}
public static void Write(Stream stream, IImageRead image)
{
using (var bitmap = image.CreateBitmap())
{
stream.Position = 0;
bitmap.Save(stream, ImageFormat.Tiff);
}
}
public static BitmapSource GetBimapSource(this IImageRead imageRead)
{
const double dpi = 96.0;
var size = imageRead.Size;
var data = imageRead.ToBgra32();
return(BitmapSource.Create(size.Width, size.Height, dpi, dpi, PixelFormats.Bgra32, null, data, size.Width * 4));
}
public static Texture2D CreateTexture(this IImageRead image, GraphicsDevice graphicsDevice)
{
var size = image.Size;
var texture = new Texture2D(graphicsDevice, size.Width, size.Height);
texture.SetData(image.AsRgba8888());
return(texture);
}
public ISpriteTexture CreateSpriteTexture(IImageRead image)
{
var size = image.Size;
var texture = new Texture2D(_graphicsDevice, size.Width, size.Height);
texture.SetData(image.AsRgba8888());
return(new CSpriteTexture(texture));
}
public static ISurface CreateSurface(this IDrawing drawing, IImageRead image) => drawing
.CreateSurface(image.Size.Width,
image.Size.Height,
Xe.Drawing.PixelFormat.Format32bppArgb,
SurfaceType.Input,
new DataResource
{
Data = image.AsBgra8888(),
Stride = image.Size.Width * 4
});
public static BitmapSource GetWindowsMediaImage(this IImageRead image)
{
var size = image.Size;
return(BitmapSource.Create(
size.Width, size.Height,
96.0, 96.0,
GetPixelFormat(image.PixelFormat),
GetPalette(image),
image.GetData(),
size.Width * GetBpp(image.PixelFormat) / 8));
}
public static byte[] AsRgba8888(this IImageRead image)
{
switch (image.PixelFormat)
{
case PixelFormat.Indexed4: return(image.From4bpp(Rgba));
case PixelFormat.Indexed8: return(image.From8bpp(Rgba));
default:
throw new ArgumentException($"The pixel format {image.PixelFormat} is not supported.");
}
}
private static byte[] From32bpp(this IImageRead image, byte[] channelOrder)
{
var srcData = image.GetData();
var dstData = new byte[srcData.Length];
for (var i = 0; i < srcData.Length; i += 4)
{
dstData[i + 0] = srcData[i + channelOrder[0]];
dstData[i + 1] = srcData[i + channelOrder[1]];
dstData[i + 2] = srcData[i + channelOrder[2]];
dstData[i + 3] = srcData[i + channelOrder[3]];
}
return(dstData);
}
public static byte[] ToBgra32(this IImageRead imageRead)
{
switch (imageRead.PixelFormat)
{
case PixelFormat.Indexed4:
return(ImageDataHelpers.FromIndexed4ToBgra(imageRead.GetData(), imageRead.GetClut()));
case PixelFormat.Indexed8:
return(ImageDataHelpers.FromIndexed8ToBgra(imageRead.GetData(), imageRead.GetClut()));
case PixelFormat.Rgba8888:
return(imageRead.GetData());
default:
throw new NotImplementedException($"The PixelFormat {imageRead.PixelFormat} cannot be converted to a Bgra32.");
}
}
private static BitmapPalette GetPalette(IImageRead image)
{
var clut = image.GetClut();
int colorsCount = clut.Length / 4;
if (colorsCount == 0)
{
return(null);
}
var colors = new List <Color>(colorsCount);
for (var i = 0; i < colorsCount; i++)
{
colors.Add(GetColor(clut, i * 4));
}
return(new BitmapPalette(colors));
}
public static byte[] AsRgba8888(this IImageRead image)
{
switch (image.PixelFormat)
{
case PixelFormat.Indexed4:
return(ImageDataHelpers.FromIndexed4ToBitmap32(
image.GetData(), image.GetClut(), Rgba));
case PixelFormat.Indexed8:
return(ImageDataHelpers.FromIndexed8ToBitmap32(
image.GetData(), image.GetClut(), Rgba));
case PixelFormat.Rgba8888:
return(ImageDataHelpers.FromBitmap32(image.GetData(), Bgra));
default:
throw new ArgumentException($"The pixel format {image.PixelFormat} is not supported.");
}
}
public static Imgd AsImgd(this IImageRead image, bool isSwizzled = false)
{
if (image is Imgd imgd)
{
return(imgd);
}
else
{
switch (image.PixelFormat)
{
case PixelFormat.Rgba8888:
case PixelFormat.Rgbx8888:
return(new Imgd(image.Size, image.PixelFormat, GetAsRGBA(image.GetData()), image.GetClut(), isSwizzled));
default:
return(new Imgd(image.Size, image.PixelFormat, image.GetData(), image.GetClut(), isSwizzled));
}
}
}
public static Texture2D CreateTexture(this IImageRead image, GraphicsDevice graphicsDevice)
{
var size = image.Size;
var texture = new Texture2D(graphicsDevice, size.Width, size.Height);
if (image.PixelFormat != PixelFormat.Rgba1555)
{
texture.SetData(image.AsBgra8888());
}
else
{
texture = new Texture2D(graphicsDevice, 1, 1);
byte[] pix = new byte[4];
pix[0] = 0xFF;
pix[1] = 0xFF;
pix[2] = 0xFF;
pix[3] = 0xFF;
texture.SetData(pix);
}
return(texture);
}
private static DataResource GetDataResource(IImageRead image)
{
byte[] data;
switch (image.PixelFormat)
{
case Imaging.PixelFormat.Indexed4:
data = GetDataResource4bpp(image);
break;
case Imaging.PixelFormat.Indexed8:
data = GetDataResource8bpp(image);
break;
default:
throw new ArgumentException($"The pixel format {image.PixelFormat} is not supported.");
}
return(new DataResource
{
Data = data,
Stride = image.Size.Width * 4
});
}
internal static Bitmap CreateBitmap(this IImageRead imageRead)
{
var drawingPixelFormat = imageRead.PixelFormat.GetDrawingPixelFormat();
Bitmap bitmap = new Bitmap(imageRead.Size.Width, imageRead.Size.Height, drawingPixelFormat);
var rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
var bitmapData = bitmap.LockBits(rect, ImageLockMode.WriteOnly, drawingPixelFormat);
var srcData = imageRead.GetData();
var dstLength = Math.Min(srcData.Length, bitmapData.Stride * bitmapData.Height);
Marshal.Copy(srcData, 0, bitmapData.Scan0, dstLength);
bitmap.UnlockBits(bitmapData);
var isIndexed = imageRead.PixelFormat.IsIndexed();
if (isIndexed)
{
var palette = bitmap.Palette;
var clut = imageRead.GetClut();
var colorsCount = Math.Min(clut.Length / 4, palette.Entries.Length);
for (var i = 0; i < colorsCount; i++)
{
palette.Entries[i] = Color.FromArgb(
clut[i * 4 + 3],
clut[i * 4 + 0],
clut[i * 4 + 1],
clut[i * 4 + 2]);
}
bitmap.Palette = palette;
}
return(bitmap);
}
public ImageViewModel(IImageRead image, int index = -1)
{
Source = image;
Bitmap = Source.GetBimapSource();
Index = index;
}
public void Write(Stream stream, IImageRead image) => write(stream, image);
private void InitializeSurface(ref ISpriteTexture spriteTexture, IImageRead image)
{
spriteTexture?.Dispose();
spriteTexture = _drawing?.CreateSpriteTexture(image);
}
public ISpriteTexture CreateSpriteTexture(IImageRead image) => CreateSpriteTexture(image.Size.Width, image.Size.Height, image.ToBgra32());
public ImageHandler(IImageRead imageRead)
{
_imageRead = imageRead;
}
public TextureModel(IImageRead image)
{
MasterImage = image;
}
public static ISurface CreateSurface(this IDrawing drawing, IImageRead image) => drawing
.CreateSurface(image.Size.Width,
image.Size.Height,
Xe.Drawing.PixelFormat.Format32bppArgb,
SurfaceType.Input,
GetDataResource(image));
public static Imgd AsImgd(this IImageRead image, bool isSwizzled = false) => new Imgd(image.Size, image.PixelFormat, image.GetData(), image.GetClut(), isSwizzled);
private void InitializeSurface(ref ISurface surface, IImageRead image)
{
surface?.Dispose();
surface = _drawing?.CreateSurface(image);
}
