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)));