public void ReadHeaderTest() => Common.FileOpenRead(FilePath, stream =>
{
var image = Imgd.Read(stream);
Assert.Equal(128, image.Size.Width);
Assert.Equal(128, image.Size.Height);
Assert.Equal(PixelFormat.Indexed8, image.PixelFormat);
});
private void RepackFunction()
{
List <Imgd> _tList = new List <Imgd>();
string _rPath = "";
foreach (var filePath in SelectedItemPaths)
{
if (_rPath == "")
{
_rPath = Path.GetDirectoryName(filePath);
}
using (FileStream _cStream = new FileStream(filePath, FileMode.Open))
{
Imgd _tImage = Imgd.Read(_cStream);
_tList.Add(_tImage);
_cStream.Close();
}
}
using (FileStream _oStream = new FileStream(_rPath + "\\output.imz", FileMode.OpenOrCreate))
{
Imgz.Write(_oStream, _tList.ToArray());
_oStream.Close();
}
}
public void IsCreatingCorrectlyTest(string baseName) =>
Common.FileOpenRead($"kh2/res/image-{baseName}.imd", stream =>
{
var expectedData = new byte[stream.Length];
stream.Read(expectedData, 0, expectedData.Length);
var image = Imgd.Read(new MemoryStream(expectedData));
using (var dstStream = new MemoryStream(expectedData.Length))
{
var newImage = Imgd.Create(
image.Size,
image.PixelFormat,
image.GetData(),
image.GetClut(),
image.IsSwizzled);
Assert.Equal(image.GetClut(), newImage.GetClut());
Assert.Equal(image.GetData(), newImage.GetData());
newImage.Write(dstStream);
dstStream.Position = 0;
var actualData = new byte[dstStream.Length];
dstStream.Read(actualData, 0, actualData.Length);
Assert.Equal(expectedData.Length, actualData.Length);
Assert.Equal(expectedData, actualData);
}
});
public static IEnumerable <Imgd> FromFileToImgdList(string anyFile, int bitsPerPixel, Func <Bitmap, Bitmap> quantizer, bool swizzle)
{
switch (Path.GetExtension(anyFile).ToLowerInvariant())
{
case ".png":
{
yield return(new Bitmap(anyFile).Using(bitmap => ToImgd(bitmap, bitsPerPixel, quantizer, swizzle)));
break;
}
case ".imd":
{
yield return(File.OpenRead(anyFile).Using(stream => Imgd.Read(stream)));
break;
}
case ".imz":
{
foreach (var imgd in File.OpenRead(anyFile).Using(stream => Imgz.Read(stream)))
{
yield return(imgd);
}
break;
}
}
}
private static void PatchFile(Context context, AssetFile assetFile, Stream stream)
{
if (assetFile == null)
{
throw new Exception("Asset file is null.");
}
switch (assetFile.Method)
{
case "copy":
CopyFile(context, assetFile, stream);
break;
case "bar":
case "binarc":
PatchBinarc(context, assetFile, stream);
break;
case "imd":
case "imgd":
CreateImageImd(context, assetFile.Source[0]).Write(stream);
break;
case "imz":
case "imgz":
PatchImageImz(context, assetFile, stream);
break;
case "fac":
Imgd.WriteAsFac(stream, assetFile.Source.Select(x => CreateImageImd(context, x)));
break;
case "kh2msg":
PatchKh2Msg(context, assetFile.Source, stream);
break;
case "areadatascript":
PatchAreaDataScript(context, assetFile.Source, stream);
break;
case "spawnpoint":
PatchSpawnPoint(context, assetFile, stream);
break;
case "listpatch":
PatchList(context, assetFile.Source, stream);
break;
default:
Log.Warn($"Method '{assetFile.Method}' not recognized for '{assetFile.Name}'. Falling back to 'copy'");
CopyFile(context, assetFile, stream);
break;
}
stream.SetLength(stream.Position);
}
public void TestPixelOrder8() => CreateImgdAndComparePixelData(
new byte[] { 0x12, 0x34, 0x56, 0x78, },
pixelData => Imgd.Create(
new System.Drawing.Size(2, 2),
PixelFormat.Indexed8,
pixelData,
new byte[4 * 256],
false
)
);
public void ProcessMultipleTest()
{
var patcher = new PatcherProcessor();
var patch = new Metadata
{
Assets = new List <AssetFile>
{
new AssetFile
{
Name = "somedir/somefile.bar",
Method = "binarc",
Multi = new List <Multi>
{
new Multi {
Name = "somedir/another.bar"
}
},
Source = new List <AssetFile>
{
new AssetFile
{
Name = "test",
Method = "imgd",
Type = "imgd",
Source = new List <AssetFile>
{
new AssetFile
{
Name = "sample.png",
IsSwizzled = false
}
}
}
}
}
}
};
File.Copy("Imaging/res/png/32.png", Path.Combine(ModInputDir, "sample.png"));
patcher.Patch(AssetsInputDir, ModOutputDir, patch, ModInputDir);
AssertFileExists(ModOutputDir, patch.Assets[0].Name);
AssertBarFile("test", entry =>
{
Assert.True(Imgd.IsValid(entry.Stream));
}, ModOutputDir, patch.Assets[0].Name);
AssertFileExists(ModOutputDir, patch.Assets[0].Multi[0].Name);
AssertBarFile("test", entry =>
{
Assert.True(Imgd.IsValid(entry.Stream));
}, ModOutputDir, patch.Assets[0].Multi[0].Name);
}
public void IsValidTest()
{
using (var stream = new MemoryStream())
{
stream.WriteByte(0x49);
stream.WriteByte(0x4d);
stream.WriteByte(0x47);
stream.WriteByte(0x44);
stream.Position = 0;
Assert.True(Imgd.IsValid(stream));
}
}
public void TestPixelOrder8Swizzled() => CreateImgdAndComparePixelData(
new byte[] { 0x12, 0x34, 0x56, 0x78, }
.Concat(new byte[128 * 64 - 4])
.ToArray(),
pixelData => Imgd.Create(
new System.Drawing.Size(128, 64),
PixelFormat.Indexed8,
pixelData,
new byte[4 * 256],
true
)
);
public void TestPixelOrder4Swizzled() => CreateImgdAndComparePixelData(
new byte[] { 0x12, 0x34, }
.Concat(new byte[128 * 128 / 2 - 2])
.ToArray(),
pixelData => Imgd.Create(
new System.Drawing.Size(128, 128),
PixelFormat.Indexed4,
pixelData,
new byte[4 * 16],
true
)
);
public void ReadAndWriteFac() =>
File.OpenRead(FacFilePath)
.Using(x => Helpers.AssertStream(x, inStream =>
{
var images = Imgd.ReadAsFac(inStream).ToList();
Assert.Equal(3, images.Count);
var outStream = new MemoryStream();
Imgd.WriteAsFac(outStream, images);
return(outStream);
}));
protected int OnExecute(CommandLineApplication app)
{
var target = File.OpenRead(InputFile).Using(stream => Imgd.Read(stream));
Console.WriteLine(
FormatterFactory.GetFormatterPairs()
.First()
.FormatToString(ImgdSummary.From(target))
);
return(0);
}
internal static ImgdSummary From(Imgd it)
{
return(new ImgdSummary
{
PixelFormat = it.PixelFormat.ToString(),
Width = it.Size.Width,
Height = it.Size.Height,
IsSwizzled = it.IsSwizzled,
ExpectedDataLen = ImgdSanityChecking.GetExpectedDataLen(it),
ActualDataLen = it.Data.Length,
ActualClutLen = it.Clut?.Length,
});
}
public void Kh2MergeImzTest()
{
var patcher = new PatcherProcessor();
var patch = new Metadata
{
Assets = new List <AssetFile>
{
new AssetFile
{
Name = "out.imz",
Method = "imgz",
Source = new List <AssetFile>
{
new AssetFile
{
Name = "test.imd",
Index = 1,
}
}
}
}
};
var tmpImd = Imgd.Create(new System.Drawing.Size(16, 16), PixelFormat.Indexed4, new byte[16 * 16 / 2], new byte[4], false);
var patchImd = Imgd.Create(new System.Drawing.Size(32, 16), PixelFormat.Indexed4, new byte[32 * 16 / 2], new byte[4], false);
CreateFile(AssetsInputDir, "out.imz").Using(x =>
{
Imgz.Write(x, new Imgd[]
{
tmpImd,
tmpImd,
tmpImd,
});
});
CreateFile(ModInputDir, "test.imd").Using(patchImd.Write);
patcher.Patch(AssetsInputDir, ModOutputDir, patch, ModInputDir);
AssertFileExists(ModOutputDir, "out.imz");
File.OpenRead(Path.Combine(ModOutputDir, "out.imz")).Using(x =>
{
var images = Imgz.Read(x).ToList();
Assert.Equal(3, images.Count);
Assert.Equal(16, images[0].Size.Width);
Assert.Equal(32, images[1].Size.Width);
Assert.Equal(16, images[2].Size.Width);
});
}
protected int OnExecute(CommandLineApplication app)
{
var inputFile = ImdFile;
var outputFile = OutputPng ?? Path.GetFullPath(Path.GetFileName(Path.ChangeExtension(inputFile, ".png")));
Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
using (var stream = File.OpenRead(inputFile))
{
var imgd = Imgd.Read(stream);
var bitmap = ImgdBitmapUtil.ToBitmap(imgd);
bitmap.Save(outputFile);
}
return(0);
}
public void CreateAndRead4bppSuccessfully()
{
var imgd = Imgd.Create(
new System.Drawing.Size(ImageDecodeTests.Width, ImageDecodeTests.Height),
PixelFormat.Indexed4,
ImageDecodeTests.Data4bpp, ImageDecodeTests.Clut4bpp, false);
Assert.Equal(ImageDecodeTests.ExpectedFrom4bpp, imgd.ToBgra32());
using var stream = new MemoryStream();
imgd.Write(stream);
imgd = Imgd.Read(stream.SetPosition(0));
Assert.Equal(ImageDecodeTests.ExpectedFrom4bpp, imgd.ToBgra32());
}
private static Imgd CreateImageImd(Context context, AssetFile source)
{
var srcFile = context.GetSourceModAssetPath(source.Name);
using var srcStream = File.OpenRead(srcFile);
if (PngImage.IsValid(srcStream))
{
var png = PngImage.Read(srcStream);
return(Imgd.Create(png.Size, png.PixelFormat, png.GetData(), png.GetClut(), source.IsSwizzled));
}
else if (Imgd.IsValid(srcStream))
{
return(Imgd.Read(srcStream));
}
throw new Exception($"Image source '{source.Name}' not recognized");
}
static ImageFormatService()
{
imageFormat = new IImageFormat[]
{
GetImageFormat("PNG", "png", true, Png.IsValid, Png.Read, (stream, image) => Png.Write(stream, image)),
GetImageFormat("BMP", "bmp", true, Bmp.IsValid, Bmp.Read, (stream, image) => Bmp.Write(stream, image)),
GetImageFormat("TIFF", "tiff", true, Tiff.IsValid, Tiff.Read, (stream, image) => Tiff.Write(stream, image)),
GetImageFormat("FAC", "fac", true, Imgd.IsFac, s => Imgd.ReadAsFac(s), (stream, images) =>
Imgd.WriteAsFac(stream, images.Select(x => x.AsImgd()))),
GetImageFormat("IMGD", "imd", true, Imgd.IsValid, Imgd.Read, (stream, image) => image.AsImgd().Write(stream)),
GetImageFormat("IMGZ", "imz", true, Imgz.IsValid, s => Imgz.Read(s), (stream, images) =>
Imgz.Write(stream, images.Select(x => x.AsImgd()))),
GetImageFormat("KH2 Font", "bar", true, IsKh2Font, ReadKh2Font, WriteKh2Font),
GetImageFormat("Font ARC", "arc", false, FontsArc.IsValid, s =>
{
var fonts = FontsArc.Read(s);
return(new[]
{
fonts.FontCmd.Image1,
fonts.FontCmd.Image2,
fonts.FontHelp.Image1,
fonts.FontHelp.Image2,
fonts.FontMenu.Image1,
fonts.FontMenu.Image2,
fonts.FontMes.Image1,
fonts.FontMes.Image2,
fonts.FontNumeral.Image1,
fonts.FontNumeral.Image2,
fonts.FontIcon,
});
}, (stream, images) =>
throw new NotImplementedException()),
GetImageFormat("TIM2", "tm2", false, Tm2.IsValid, s => Tm2.Read(s), (stream, images) =>
throw new NotImplementedException()),
GetImageFormat("KH2TIM", "tex", false, _ => true,
s => ModelTexture.Read(s).Images.Cast <IImageRead>(),
(stream, images) => throw new NotImplementedException()),
};
public void IsWritingBackCorrectly(string baseName) =>
Common.FileOpenRead($"kh2/res/image-{baseName}.imd", stream =>
{
var expectedData = new byte[stream.Length];
stream.Read(expectedData, 0, expectedData.Length);
var image = Imgd.Read(new MemoryStream(expectedData));
using (var dstStream = new MemoryStream(expectedData.Length))
{
image.Write(dstStream);
dstStream.Position = 0;
var actualData = new byte[dstStream.Length];
dstStream.Read(actualData, 0, actualData.Length);
Assert.Equal(expectedData.Length, actualData.Length);
Assert.Equal(expectedData, actualData);
}
});
private void ConvertPNG()
{
foreach (var filePath in SelectedItemPaths)
{
using (FileStream _cStream = new FileStream(filePath, FileMode.Open))
{
Imgd _tImage = Imgd.Read(_cStream);
var size = _tImage.Size;
var data = _tImage.ToBgra32();
MarshalBitmap _tBitmap = new MarshalBitmap(size.Width, size.Height, data);
_tBitmap.Bitmap.Save(filePath.Replace(".imd", ".png"));
_tBitmap.Dispose();
}
}
}
protected override Bitmap GetThumbnailImage(uint width)
{
using (MemoryStream _cStream = new MemoryStream())
{
SelectedItemStream.CopyTo(_cStream);
_tImage = new Lazy <IImageRead>(() => Imgd.Read(_cStream));
var size = _tImage.Value.Size;
var data = _tImage.Value.ToBgra32();
using (MarshalBitmap _tBitmap = new MarshalBitmap(size.Width, size.Height, data))
{
_rBitmap = new Lazy <Bitmap>(() => new Bitmap(_tBitmap.Bitmap, (int)width, (int)width));
return(_rBitmap.Value);
}
}
}
internal static int?GetExpectedDataLen(Imgd it)
{
switch (it.PixelFormat)
{
case Imaging.PixelFormat.Indexed4:
return((it.Size.Width * it.Size.Height + 1) / 2);
case Imaging.PixelFormat.Indexed8:
return(it.Size.Width * it.Size.Height);
case Imaging.PixelFormat.Rgb888:
return(3 * it.Size.Width * it.Size.Height);
case Imaging.PixelFormat.Rgba8888:
case Imaging.PixelFormat.Rgbx8888:
return(4 * it.Size.Width * it.Size.Height);
}
return(null);
}
void CreateImgdAndComparePixelData(
byte[] pixelData,
Func <byte[], Imgd> imgdFactory
)
{
var imgd = imgdFactory(pixelData);
var temp = new MemoryStream();
imgd.Write(temp);
temp.Position = 0;
var loaded = Imgd.Read(temp);
Assert.Equal(
pixelData,
loaded.GetData()
);
}
public void WriteRgba8888PixelOrder()
{
var actual = new MemoryStream();
Imgd
.Create(
new Size(2, 2),
PixelFormat.Rgba8888,
new byte[] {
// Input: R, G, B, A
0x27, 0x7F, 0xFF, 0xFF,
0x4C, 0xB1, 0x22, 0xFF,
0xE8, 0xA2, 0x00, 0xFF,
0x00, 0xF2, 0xFF, 0xFF,
},
null,
false
)
.Write(actual);
var expectedData = File.ReadAllBytes($"kh2/res/2x2x32.imd");
Assert.Equal(expectedData, actual.ToArray());
}
public static Imgd ToImgd(Bitmap bitmap)
{
switch (bitmap.PixelFormat)
{
case PixelFormat.Format4bppIndexed:
{
var destHeight = bitmap.Height;
var destStride = (bitmap.Width + 1) & (~1);
var destBits = new byte[destStride * destHeight];
var src = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), ImageLockMode.ReadOnly, bitmap.PixelFormat);
try
{
for (int y = 0; y < bitmap.Height; y++)
{
Marshal.Copy(src.Scan0 + src.Stride * y, destBits, destStride * y, destStride);
}
}
finally
{
bitmap.UnlockBits(src);
}
var clut = new byte[4 * 16];
{
var palette = bitmap.Palette;
for (int index = 0; index < 16; index++)
{
var color = palette.Entries[index];
clut[4 * index + 0] = color.R;
clut[4 * index + 1] = color.G;
clut[4 * index + 2] = color.B;
clut[4 * index + 3] = color.A;
}
bitmap.Palette = palette;
}
return(Imgd.Create(bitmap.Size, Imaging.PixelFormat.Indexed4, destBits, clut, false));
}
case PixelFormat.Format8bppIndexed:
{
var destHeight = bitmap.Height;
var destStride = bitmap.Width;
var destBits = new byte[destStride * destHeight];
var src = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), ImageLockMode.ReadOnly, bitmap.PixelFormat);
try
{
for (int y = 0; y < bitmap.Height; y++)
{
Marshal.Copy(src.Scan0 + src.Stride * y, destBits, destStride * y, destStride);
}
}
finally
{
bitmap.UnlockBits(src);
}
var clut = new byte[4 * 256];
{
var palette = bitmap.Palette;
for (int index = 0; index < 256; index++)
{
var color = palette.Entries[index];
clut[4 * index + 0] = color.R;
clut[4 * index + 1] = color.G;
clut[4 * index + 2] = color.B;
clut[4 * index + 3] = color.A;
}
bitmap.Palette = palette;
}
return(Imgd.Create(bitmap.Size, Imaging.PixelFormat.Indexed4, destBits, clut, false));
}
}
throw new NotSupportedException($"{bitmap.PixelFormat} not recognized!");
}
public TextureModel(int index, Imgd imgd)
{
Index = index;
Texture = imgd;
Image = imgd.GetBimapSource();
}
public static Imgd ToImgd(Bitmap bitmap, int bpp, Func <Bitmap, Bitmap> quantizer, bool swizzle = false)
{
if (quantizer != null)
{
var firstSrc = new ReadAs32bppPixels(bitmap);
if (PaletteColorUsageCounter.IfMaxColorCountIsOver(firstSrc.Pixels, 1 << bpp))
{
bitmap = quantizer(bitmap);
}
}
switch (bpp)
{
case 4:
{
const int maxColors = 16;
var src = new ReadAs32bppPixels(bitmap);
var newPalette = new PaletteGenerator(src.Pixels, maxColors);
if (newPalette.MaxUsedColors > newPalette.MostUsedPixels.Length)
{
Console.WriteLine(
$"Trimming color palette entry count from {newPalette.MaxUsedColors} to ${newPalette.MostUsedPixels.Length}"
);
}
var destBits = new byte[(src.Width * src.Height + 1) / 2];
var clut = new byte[4 * maxColors];
for (int index = 0; index < newPalette.MostUsedPixels.Length; index++)
{
var pixel = newPalette.MostUsedPixels[index];
clut[4 * index + 0] = (byte)(pixel >> 16);
clut[4 * index + 1] = (byte)(pixel >> 8);
clut[4 * index + 2] = (byte)(pixel >> 0);
clut[4 * index + 3] = (byte)(pixel >> 24);
}
var srcPointer = 0;
var destPointer = 0;
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
var newPixel = newPalette.FindNearest(src.Pixels[srcPointer++]) & 15;
if (0 == (x & 1))
{
// first pixel: hi byte
destBits[destPointer] = (byte)(newPixel << 4);
}
else
{
// second pixel: lo byte
destBits[destPointer++] |= (byte)(newPixel);
}
}
}
return(Imgd.Create(bitmap.Size, Imaging.PixelFormat.Indexed4, destBits, clut, swizzle));
}
case 8:
{
const int maxColors = 256;
var src = new ReadAs32bppPixels(bitmap);
var newPalette = new PaletteGenerator(src.Pixels, maxColors);
if (newPalette.MaxUsedColors > newPalette.MostUsedPixels.Length)
{
Console.WriteLine(
$"Trimming color palette entry count from {newPalette.MaxUsedColors} to ${newPalette.MostUsedPixels.Length}"
);
}
var destBits = new byte[src.Width * src.Height];
var clut = new byte[4 * maxColors];
for (int index = 0; index < newPalette.MostUsedPixels.Length; index++)
{
var pixel = newPalette.MostUsedPixels[index];
clut[4 * index + 0] = (byte)(pixel >> 16);
clut[4 * index + 1] = (byte)(pixel >> 8);
clut[4 * index + 2] = (byte)(pixel >> 0);
clut[4 * index + 3] = (byte)(pixel >> 24);
}
var srcPointer = 0;
var destPointer = 0;
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
destBits[destPointer++] = (byte)newPalette.FindNearest(src.Pixels[srcPointer++]);
}
}
return(Imgd.Create(bitmap.Size, Imaging.PixelFormat.Indexed8, destBits, clut, swizzle));
}
case 32:
{
var src = new ReadAs32bppPixels(bitmap);
var destBits = new byte[4 * src.Width * src.Height];
var srcPointer = 0;
var destPointer = 0;
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
var pixel = src.Pixels[srcPointer++];
destBits[destPointer + 0] = (byte)(pixel >> 16);
destBits[destPointer + 1] = (byte)(pixel >> 8);
destBits[destPointer + 2] = (byte)(pixel >> 0);
destBits[destPointer + 3] = (byte)(pixel >> 24);
destPointer += 4;
}
}
return(Imgd.Create(bitmap.Size, Imaging.PixelFormat.Rgba8888, destBits, new byte[0], swizzle));
}
}
throw new NotSupportedException($"BitsPerPixel {bpp} not recognized!");
}
public static Bitmap ToBitmap(Imgd imgd)
{
switch (imgd.PixelFormat)
{
case Imaging.PixelFormat.Indexed4:
{
var bitmap = new Bitmap(imgd.Size.Width, imgd.Size.Height, PixelFormat.Format4bppIndexed);
var dest = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), ImageLockMode.WriteOnly, bitmap.PixelFormat);
try
{
var sourceBits = imgd.GetData();
var sourceWidth = imgd.Size.Width;
var sourceStride = ((sourceWidth + 1) / 2) & (~1);
for (int y = 0; y < bitmap.Height; y++)
{
Marshal.Copy(sourceBits, sourceStride * y, dest.Scan0 + dest.Stride * y, sourceStride);
}
}
finally
{
bitmap.UnlockBits(dest);
}
{
var clut = imgd.GetClut();
var palette = bitmap.Palette;
for (int index = 0; index < 16; index++)
{
palette.Entries[index] = Color.FromArgb(
clut[4 * index + 3],
clut[4 * index + 0],
clut[4 * index + 1],
clut[4 * index + 2]
);
}
bitmap.Palette = palette;
}
return(bitmap);
}
case Imaging.PixelFormat.Indexed8:
{
var bitmap = new Bitmap(imgd.Size.Width, imgd.Size.Height, PixelFormat.Format8bppIndexed);
var dest = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), ImageLockMode.WriteOnly, bitmap.PixelFormat);
try
{
var sourceBits = imgd.GetData();
var sourceWidth = imgd.Size.Width;
for (int y = 0; y < bitmap.Height; y++)
{
Marshal.Copy(sourceBits, sourceWidth * y, dest.Scan0 + dest.Stride * y, sourceWidth);
}
}
finally
{
bitmap.UnlockBits(dest);
}
{
var clut = imgd.GetClut();
var palette = bitmap.Palette;
for (int index = 0; index < 256; index++)
{
palette.Entries[index] = Color.FromArgb(
clut[4 * index + 3],
clut[4 * index + 0],
clut[4 * index + 1],
clut[4 * index + 2]
);
}
bitmap.Palette = palette;
}
return(bitmap);
}
case Imaging.PixelFormat.Rgba8888:
{
var bitmap = new Bitmap(imgd.Size.Width, imgd.Size.Height, PixelFormat.Format32bppPArgb);
var dest = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), ImageLockMode.WriteOnly, bitmap.PixelFormat);
try
{
var sourceBits = imgd.GetData();
var sourceWidth = 4 * imgd.Size.Width;
for (int y = 0; y < bitmap.Height; y++)
{
Marshal.Copy(sourceBits, sourceWidth * y, dest.Scan0 + dest.Stride * y, sourceWidth);
}
}
finally
{
bitmap.UnlockBits(dest);
}
return(bitmap);
}
}
throw new NotSupportedException($"{imgd.PixelFormat} not recognized!");
}
public void CreateAndRead(string baseName)
{
var image = File.OpenRead($"kh2/res/image-{baseName}.imd").Using(s => Imgd.Read(s));
{
var outStream = new MemoryStream();
{
var textures = new ModelTexture(new Imgd[] { image });
textures.Write(outStream);
}
{
outStream.Position = 0;
var textures = ModelTexture.Read(outStream);
Assert.Single(textures.Images);
var converted = textures.Images.Single();
Assert.Equal(image.PixelFormat, converted.PixelFormat);
Assert.Equal(image.Size, converted.Size);
Assert.Equal(image.GetClut(), converted.GetClut());
Assert.Equal(image.GetData(), converted.GetData());
}
}
{
var outStream = new MemoryStream();
{
var textures = new ModelTexture(new Imgd[] { image, image });
textures.Write(outStream);
}
{
outStream.Position = 0;
var textures = ModelTexture.Read(outStream);
Assert.Equal(2, textures.Images.Count);
foreach (var converted in textures.Images)
{
Assert.Equal(image.PixelFormat, converted.PixelFormat);
Assert.Equal(image.Size, converted.Size);
Assert.Equal(image.GetClut(), converted.GetClut());
Assert.Equal(image.GetData(), converted.GetData());
}
}
}
{
var outStream = new MemoryStream();
{
var textures = new ModelTexture(new Imgd[] { image, image, image, image });
textures.Write(outStream);
}
{
outStream.Position = 0;
var textures = ModelTexture.Read(outStream);
Assert.Equal(4, textures.Images.Count);
foreach (var converted in textures.Images)
{
Assert.Equal(image.PixelFormat, converted.PixelFormat);
Assert.Equal(image.Size, converted.Size);
Assert.Equal(image.GetClut(), converted.GetClut());
Assert.Equal(image.GetData(), converted.GetData());
}
}
}
}
public void IsFac(string fileName, bool expected) => Assert.Equal(expected, File.OpenRead(fileName).Using(stream => Imgd.IsFac(stream)));
