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 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;
}
}
}
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 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);
});
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);
}
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");
}
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);
}
});
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);
}
}
}
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();
}
}
}
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 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());
}
}
}
}
private Imgd FileLoader(string filePath, MaterialDef matDef, MapGenConfig config)
{
logger.Debug($"Load image from \"{filePath}\"");
if (FileExtUtil.IsExtension(filePath, ".imd"))
{
return(ImageResizer.NormalizeImageSize(File.OpenRead(filePath).Using(s => Imgd.Read(s))));
}
if (FileExtUtil.IsExtension(filePath, ".png"))
{
var imdFile = Path.ChangeExtension(filePath, ".imd");
if (config.skipConversionIfExists && File.Exists(imdFile))
{
logger.Debug($"Skipping png to imd conversion, due to imd file existence and skipConversionIfExists option.");
}
else
{
try
{
logger.Debug($"Using ImgTool for png to imd conversion.");
var imgtoolOptions = matDef.imgtoolOptions ?? config.imgtoolOptions ?? "-b 8";
var result = new RunCmd(
"OpenKh.Command.ImgTool.exe",
$"imd \"{filePath}\" -o \"{imdFile}\" {imgtoolOptions}"
);
if (result.ExitCode != 0)
{
throw new Exception($"ImgTool failed ({result.ExitCode})");
}
}
catch (Win32Exception ex)
{
throw new Exception("ImgTool failed.", ex);
}
}
return(FileLoader(imdFile, matDef, config));
}
throw new NotSupportedException(Path.GetExtension(filePath));
}
