public void UpscaleImage(ImageFile ddsfile)
{
ImageSize newImgSize = ddsfile.imgSize;
ImageSize topImgSize = imgList.First().imgSize;
List<ImageInfo> newImgs = new List<ImageInfo>();
// First of all, add in all missing values in between
ImageInfo newImg = new ImageInfo();
newImg.cprSize = 0;
newImg.uncSize = 0;
newImg.storageType = storage.empty;
newImg.offset = -1;
newImg.imgSize = newImgSize;
newImgs.Add(newImg);
while ((topImgSize.width * 2) != newImgs.Last().imgSize.width && (topImgSize.height * 2) != newImgs.Last().imgSize.height)
{
newImg = new ImageInfo();
newImg.cprSize = 0;
newImg.uncSize = 0;
newImg.storageType = storage.empty;
newImg.offset = -1;
newImg.imgSize = new ImageSize(newImgs.Last().imgSize.width / 2, newImgs.Last().imgSize.height / 2);
// ^Slightly naive solution as it will fail on compressed textures smaller than 4x4, but since this is an upscale mechanism this shouldn't happen
newImgs.Add(newImg);
}
imgList.InsertRange(0, newImgs); // Insert the new list
ReplaceImage(ddsfile); // And regular replace
}
public void AddMissingImage(ImageFile ddsfile)
{
ImageInfo newImg = new ImageInfo();
newImg.storageType = storage.empty;
newImg.imgSize = ddsfile.imgSize;
newImg.cprSize = 0;
newImg.uncSize = 0;
newImg.offset = -1;
ImageInfo lastImg = imgList.Last();
if (newImg.imgSize.width < lastImg.imgSize.width && newImg.imgSize.height < lastImg.imgSize.height) // Simple solution. Should normally be necessary
{
imgList.Add(newImg);
ReplaceImage(ddsfile);
return;
}
for (int i = 0; i < imgList.Count; i++) // Catch solution
{
if (newImg.imgSize.width < imgList[i].imgSize.width)
continue;
imgList.Insert(i, newImg);
ReplaceImage(ddsfile);
return;
}
throw new Exception("Couldn't add missing image!"); // Safety catch
}
public void replaceImage(string strImgSize, ImageFile im, string archiveDir)
{
//DebugOutput.PrintLn( "\nIn replace image...\n");
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!privateimgList.Exists(img => img.imgSize == imgSize))
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
int imageIdx = privateimgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateimgList[imageIdx];
ImageFile imgFile = im;
ImageEngineFormat imgFileFormat = Textures.Methods.ParseFormat(imgFile.format);
// check if images have same format type
if (texFormat != imgFileFormat && texFormat != ImageEngineFormat.DDS_G8_L8)
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
//string archivePath = GetTexArchive(archiveDir);
string archivePath = FullArcPath;
if (String.IsNullOrEmpty(archivePath))
archivePath = GetTexArchive(archiveDir);
if (archivePath == null)
throw new FileNotFoundException("Teture archive not found!");
if (!File.Exists(archivePath))
throw new FileNotFoundException("Texture archive not found in " + archivePath);
if (getFileFormat() == ".tga")
imgBuffer = imgFile.resize(); // shrink image to essential data
else
imgBuffer = imgFile.imgData;
if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
//DebugOutput.PrintLn( "\nOK here's the stuff we came for. About to change/add cache.\n");
//DebugOutput.PrintLn( "Initial arcname = " + arcName + " custCache = " + CustCache + "\n");
if (!arcName.ToLower().Contains(Path.GetFileNameWithoutExtension(MEDirectories.MEDirectories.CachePath.ToLower()))) // CachePath is usually CustTextures, but arcName can be CustTextures#, so check for substring
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
else
{
FileInfo arc = new FileInfo(archivePath);
//DebugOutput.PrintLn( "Extra bits maybe: " + arc.Length + "\n");
if (arc.Length + imgBuffer.Length >= 0x80000000)
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
}
/* FileInfo arc = new FileInfo(archivePath);
if (arc.Length + imgBuffer.Length >= 0x80000000)
{
//2GB fix
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = archiveDir + "\\" + arcName + ".tfc";
} */
using (FileStream archiveStream = new FileStream(archivePath, FileMode.Append, FileAccess.Write))
{
int newOffset = (int)archiveStream.Position;
if (imgInfo.storageType == storage.arcCpr)
{
imgBuffer = ZBlock.Compress(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
}
archiveStream.Write(imgBuffer, 0, imgBuffer.Length);
imgInfo.offset = newOffset;
}
break;
case storage.pccSto:
imgBuffer = imgFile.imgData; // copy image data as-is
if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
using (MemoryStream dataStream = new MemoryStream())
{
dataStream.WriteBytes(imageData);
if (imgBuffer.Length <= imgInfo.uncSize && imgInfo.offset > 0)
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
else
imgInfo.offset = (int)dataStream.Position;
dataStream.WriteBytes(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
imgInfo.uncSize = imgBuffer.Length;
imageData = dataStream.ToArray();
}
#region Old code
/*
try
{
using (MemoryStream dataStream = new MemoryStream(imageData))
{
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
dataStream.Write(imgBuffer, 0, imgBuffer.Length);
}
}
catch (NotSupportedException)
{
MemoryStream dataStream = new MemoryStream();
dataStream.WriteBytes(imgBuffer);
dataStream.WriteBytes(imageData);
imageData = dataStream.ToArray();
dataStream.Close();
for (int i = 1; i < imgList.Count; i++)
{
ImageInfo img = imgList[i];
img.offset += imgBuffer.Length;
imgList[i] = img;
}
}
*/
#endregion
break;
}
privateimgList[imageIdx] = imgInfo;
//this.hasChanged = true;
}
public void OneImageToRuleThemAll(ImageFile im, string archiveDir, byte[] imgData)
{
OneSizeFitsAll(imgData);
//OneImageToRuleThemAll(imageFilename);
}
public void replaceImage2(string strImgSize, ImageFile im, string archiveDir)
{
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!privateimgList.Exists(img => img.imgSize == imgSize))
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
int imageIdx = privateimgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateimgList[imageIdx];
// check if replacing image is supported
ImageFile imgFile = im;
if (!Methods.CheckTextureFormat(texFormat, imgFile.format))
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
string archivePath = FullArcPath;
if (String.IsNullOrEmpty(archivePath))
archivePath = GetTexArchive(archiveDir);
if (!File.Exists(archivePath))
throw new FileNotFoundException("Texture archive not found in " + archivePath);
imgBuffer = imgFile.imgData;
if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
if (arcName.Length <= CustCache.Length || arcName.Substring(0, CustCache.Length) != CustCache) // Check whether existing texture is in a custom cache
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
else
{
FileInfo arc = new FileInfo(archivePath);
if (arc.Length + imgBuffer.Length >= 0x80000000)
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
}
using (FileStream archiveStream = new FileStream(archivePath, FileMode.Append, FileAccess.Write))
{
int newOffset = (int)archiveStream.Position;
if (imgInfo.storageType == storage.arcCpr)
{
byte[] tempBuff;
SaltLZOHelper lzohelper = new SaltLZOHelper();
tempBuff = lzohelper.CompressTex(imgBuffer);
imgBuffer = new byte[tempBuff.Length];
Buffer.BlockCopy(tempBuff, 0, imgBuffer, 0, tempBuff.Length);
imgInfo.cprSize = imgBuffer.Length;
}
archiveStream.Write(imgBuffer, 0, imgBuffer.Length);
imgInfo.offset = newOffset;
}
break;
case storage.pccSto:
imgBuffer = imgFile.resize();
using (MemoryStream dataStream = new MemoryStream())
{
dataStream.WriteBytes(imageData);
if (imgBuffer.Length <= imgInfo.uncSize && imgInfo.offset > 0)
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
else
imgInfo.offset = (int)dataStream.Position;
dataStream.WriteBytes(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
imgInfo.uncSize = imgBuffer.Length;
imageData = dataStream.ToArray();
}
break;
}
privateimgList[imageIdx] = imgInfo;
}
public void OneImageToRuleThemAll(ImageFile im, string archiveDir, byte[] imgData)
{
ImageMipMapHandler imgMipMap = new ImageMipMapHandler("", imgData);
// starts from the smaller image
for (int i = imgMipMap.imageList.Count - 1; i >= 0; i--)
{
ImageFile newImageFile = imgMipMap.imageList[i];
if (newImageFile.imgSize.height < 4 || newImageFile.imgSize.width < 4)
continue;
ImageEngineFormat newImageFileFormat = Textures.Methods.ParseFormat(newImageFile.format);
//NEW Check for correct format
if (texFormat != newImageFileFormat)
{
//MessageBox.Show("Warning! The input image is of the wrong format! Aborting");
throw new FormatException("Different image format, original is " + texFormat + ", new is " + newImageFile.subtype());
}
// if the image size exists inside the texture2d image list then we have to replace it
if (privateimgList.Exists(img => img.imgSize == newImageFile.imgSize))
{
// ...but at least for now I can reuse my replaceImage function... ;)
replaceImage(newImageFile.imgSize.ToString(), newImageFile, archiveDir);
}
else // if the image doesn't exists then we have to add it
{
// ...and use my addBiggerImage function! :P
addBiggerImage(newImageFile, archiveDir);
}
}
while (privateimgList[0].imgSize.width > imgMipMap.imageList[0].imgSize.width)
{
privateimgList.RemoveAt(0);
numMipMaps--;
if (properties.ContainsKey("MipTailBaseIdx"))
properties["MipTailBaseIdx"].Value.IntValue--;
}
if (properties.ContainsKey("SizeX"))
properties["SizeX"].Value.IntValue = (int)imgMipMap.imageList[0].imgSize.width;
if (properties.ContainsKey("SizeY"))
properties["SizeY"].Value.IntValue = (int)imgMipMap.imageList[0].imgSize.height;
}
public void OneImageToRuleThemAll(string archiveDir, ImageFile im, out string newTextureGroup, byte[] imgData)
{
newTextureGroup = null;
ImageMipMapHandler imgMipMap = new ImageMipMapHandler("", imgData);
// starts from the smaller image
for (int i = imgMipMap.imageList.Count - 1; i >= 0; i--)
{
ImageFile newImageFile = imgMipMap.imageList[i];
// insert images only with size > 64
if (newImageFile.imgSize.width < 64 && newImageFile.imgSize.height < 64)
continue;
// if the image size exists inside the texture2d image list then we have to replace it
if (imgList.Exists(img => img.imgSize == newImageFile.imgSize))
{
// ...but at least for now I can reuse my replaceImage function... ;)
replaceImage(newImageFile.imgSize.ToString(), newImageFile, archiveDir);
}
else // if the image doesn't exists then we have to add it
{
// ...and use my addBiggerImage function! :P
addBiggerImage(newImageFile, archiveDir);
}
File.Delete(newImageFile.fileName);
}
// add texturegroup_world inside GamerSettings.ini in order to overwrite values
ImageSize maxSize = imgList.Max(image => image.imgSize);
uint maxValue = Math.Max(maxSize.width, maxSize.height);
string section = "SystemSettings";
string key = "texturegroup_shadowmap";
string newValue = "(MinLODSize=128,MaxLODSize=" + maxValue + ",LODBias=0)";
IniFile iniFile = new IniFile(ME3Directory.GamerSettingsIniFile);
string oldValue = iniFile.IniReadValue(section, key);
if (oldValue == "")
{
iniFile.IniWriteValue(section, key, newValue);
}
else
{
char[] delimiters = new char[] { '=', ',' };
uint maxLODSize = Convert.ToUInt32(oldValue.Split(delimiters)[3]);
if (maxValue > maxLODSize)
iniFile.IniWriteValue(section, key, newValue);
}
// check that Texture2D has a TextureGroup
if (!properties.ContainsKey("LODGroup"))
return;
// extracting values from LODGroup Property
PropertyReader.Property LODGroup = properties["LODGroup"];
string textureGroupName = pccRef.Names[LODGroup.Value.IntValue];
string newTextureGroupName = "TEXTUREGROUP_Shadowmap";
textureGroupName = newTextureGroupName;
if (!pccRef.Names.Exists(name => name == newTextureGroupName))
pccRef.Names.Add(newTextureGroupName);
using (MemoryStream rawStream = new MemoryStream(LODGroup.raw))
{
rawStream.Seek(32, SeekOrigin.Begin);
rawStream.WriteValueS32(pccRef.Names.FindIndex(name => name == newTextureGroupName));
//rawStream.Seek(32, SeekOrigin.Begin);
rawStream.WriteValueS32(0);
properties["LODGroup"].raw = rawStream.ToArray();
}
}
public void OneImageToRuleThemAll(ImageFile im, string archiveDir, byte[] imgData)
{
ImageMipMapHandler imgMipMap = new ImageMipMapHandler("", imgData);
if (Class == class2 || Class == class3)
ChangeFormat(imgMipMap.imageList[0].format);
// starts from the smaller image
for (int i = imgMipMap.imageList.Count - 1; i >= 0; i--)
{
ImageFile newImageFile = imgMipMap.imageList[i];
if (!Methods.CheckTextureFormat(texFormat, newImageFile.format))
throw new FormatException("Different image format, original is " + texFormat + ", new is " + newImageFile.subtype());
// if the image size exists inside the texture2d image list then we have to replace it
if (privateimgList.Exists(img => img.imgSize == newImageFile.imgSize))
{
// ...but at least for now I can reuse my replaceImage function... ;)
replaceImage(newImageFile.imgSize.ToString(), newImageFile, archiveDir);
}
else if (newImageFile.imgSize.width > privateimgList[0].imgSize.width) // if the image doesn't exists then we have to add it
{
// ...and use my addBiggerImage function! :P
addBiggerImage(newImageFile, archiveDir);
}
//else
// addMissingImage(newImageFile.imgSize.ToString(), newImageFile.fileName);
// else ignore the image
}
// Remove higher res versions and fix up properties
while (privateimgList[0].imgSize.width > imgMipMap.imageList[0].imgSize.width)
//while (imgMipMap.imageList.Count + 2 < imgList.Count)
{
privateimgList.RemoveAt(0);
numMipMaps--;
}
if (properties.ContainsKey("SizeX"))
properties["SizeX"].Value.IntValue = (int)privateimgList[0].imgSize.width;
if (properties.ContainsKey("SizeY"))
properties["SizeY"].Value.IntValue = (int)privateimgList[0].imgSize.height;
if (properties.ContainsKey("MipTailBaseIdx"))
properties["MipTailBaseIdx"].Value.IntValue = privateimgList.Count + 1;
}
public void addBiggerImage(ImageFile im, string archiveDir)
{
addBiggerImage(im);
}
public void addBiggerImage(ImageFile im, string archiveDir)
{
ImageSize biggerImageSizeOnList = imgList.Max(image => image.imgSize);
// check if replacing image is supported
ImageFile imgFile = im;
// check if image to add is valid
if (biggerImageSizeOnList.width * 2 != imgFile.imgSize.width || biggerImageSizeOnList.height * 2 != imgFile.imgSize.height)
throw new FormatException("image size " + imgFile.imgSize + " isn't valid, must be " + new ImageSize(biggerImageSizeOnList.width * 2, biggerImageSizeOnList.height * 2));
// this check avoids insertion inside textures that have only 1 image stored inside pcc
if (!privateImageList.Exists(img => img.storageType != storage.empty && img.storageType != storage.pccSto))
throw new Exception("Unable to add image, texture must have a reference to an external archive");
// !!! warning, this method breaks consistency between imgList and imageData[] !!!
ImageInfo newImgInfo = new ImageInfo();
newImgInfo.storageType = privateImageList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
newImgInfo.imgSize = imgFile.imgSize;
newImgInfo.uncSize = imgFile.resize().Length;
newImgInfo.cprSize = 0x00; // not yet filled
newImgInfo.offset = 0x00; // not yet filled
imgList.Insert(0, newImgInfo); // insert new image on top of the list
//now I let believe the program that I'm doing an image replace, saving lot of code ;)
replaceImage(newImgInfo.imgSize.ToString(), imgFile, archiveDir);
//updating num of images
numMipMaps++;
// update MipTailBaseIdx
//PropertyReader.Property MipTail = properties["MipTailBaseIdx"];
int propVal = properties["MipTailBaseIdx"].Value.IntValue;
propVal++;
properties["MipTailBaseIdx"].Value.IntValue = propVal;
//MessageBox.Show("raw size: " + properties["MipTailBaseIdx"].raw.Length + "\nproperty offset: " + properties["MipTailBaseIdx"].offsetval);
using (MemoryStream rawStream = new MemoryStream(properties["MipTailBaseIdx"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["MipTailBaseIdx"].raw = rawStream.ToArray();
}
//properties["MipTailBaseIdx"] = MipTail;
// update Sizes
//PropertyReader.Property Size = properties["SizeX"];
propVal = (int)newImgInfo.imgSize.width;
properties["SizeX"].Value.IntValue = propVal;
using (MemoryStream rawStream = new MemoryStream(properties["SizeX"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["SizeX"].raw = rawStream.ToArray();
}
//properties["SizeX"] = Size;
//Size = properties["SizeY"];
properties["SizeY"].Value.IntValue = (int)newImgInfo.imgSize.height;
using (MemoryStream rawStream = new MemoryStream(properties["SizeY"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["SizeY"].raw = rawStream.ToArray();
}
//properties["SizeY"] = Size;
properties["OriginalSizeX"].Value.IntValue = propVal;
using (MemoryStream rawStream = new MemoryStream(properties["OriginalSizeX"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["OriginalSizeX"].raw = rawStream.ToArray();
}
properties["OriginalSizeY"].Value.IntValue = propVal;
using (MemoryStream rawStream = new MemoryStream(properties["OriginalSizeY"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["OriginalSizeY"].raw = rawStream.ToArray();
}
}
public void addBiggerImage(ImageFile im)
{
ImageSize biggerImageSizeOnList = privateimgList.Max(image => image.imgSize);
// check if replacing image is supported
ImageFile imgFile = im;
if (imgFile.format == "R8G8B8")
{
byte[] buff = ImageMipMapHandler.ConvertTo32bit(imgFile.imgData, (int)imgFile.imgSize.width, (int)imgFile.imgSize.height);
imgFile = new DDS(null, imgFile.imgSize, "A8R8G8B8", buff);
}
if (!Methods.CheckTextureFormat(texFormat, imgFile.format))
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
// check if image to add is valid
if (biggerImageSizeOnList.width * 2 != imgFile.imgSize.width || biggerImageSizeOnList.height * 2 != imgFile.imgSize.height)
throw new FormatException("image size " + imgFile.imgSize + " isn't valid, must be " + new ImageSize(biggerImageSizeOnList.width * 2, biggerImageSizeOnList.height * 2));
// this check avoids insertion inside textures that have only 1 image stored inside pcc
//if (!imgList.Exists(img => img.storageType != storage.empty && img.storageType != storage.pccSto))
// throw new Exception("Unable to add image, texture must have a reference to an external archive");
if (privateimgList.Count <= 1)
throw new Exception("Unable to add image, texture must have more than one image present");
// !!! warning, this method breaks consistency between imgList and imageData[] !!!
ImageInfo newImgInfo = new ImageInfo();
newImgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
newImgInfo.imgSize = imgFile.imgSize;
newImgInfo.uncSize = imgFile.resize().Length;
newImgInfo.cprSize = 0x00; // not yet filled
newImgInfo.offset = 0x00; // not yet filled
privateimgList.Insert(0, newImgInfo); // insert new image on top of the list
//now I let believe the program that I'm doing an image replace, saving lot of code ;)
replaceImage(newImgInfo.imgSize.ToString(), im);
//updating num of images
numMipMaps++;
// update MipTailBaseIdx
//SaltPropertyReader.Property MipTail = properties["MipTailBaseIdx"];
int propVal = properties["MipTailBaseIdx"].Value.IntValue;
propVal++;
properties["MipTailBaseIdx"].Value.IntValue = propVal;
//MessageBox.Show("raw size: " + properties["MipTailBaseIdx"].raw.Length + "\nproperty offset: " + properties["MipTailBaseIdx"].offsetval);
using (MemoryStream rawStream = new MemoryStream(properties["MipTailBaseIdx"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["MipTailBaseIdx"].raw = rawStream.ToArray();
}
//properties["MipTailBaseIdx"] = MipTail;
// update Sizes
//SaltPropertyReader.Property Size = properties["SizeX"];
propVal = (int)newImgInfo.imgSize.width;
properties["SizeX"].Value.IntValue = propVal;
using (MemoryStream rawStream = new MemoryStream(properties["SizeX"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["SizeX"].raw = rawStream.ToArray();
}
//properties["SizeX"] = Size;
//Size = properties["SizeY"];
properties["SizeY"].Value.IntValue = (int)newImgInfo.imgSize.height;
using (MemoryStream rawStream = new MemoryStream(properties["SizeY"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["SizeY"].raw = rawStream.ToArray();
}
//properties["SizeY"] = Size;
//this.hasChanged = true;
}
public void replaceImage(string strImgSize, ImageFile im, bool enforceSize, string archiveDir = null)
{
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!privateimgList.Exists(img => img.imgSize == imgSize))
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
int imageIdx = privateimgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateimgList[imageIdx];
// check if replacing image is supported
ImageFile imgFile = im;
// Heff: Made this check optional to allow for replacing with larger images.
if (enforceSize && (imgFile.imgSize.height != imgInfo.imgSize.height || imgFile.imgSize.width != imgInfo.imgSize.width))
throw new FormatException("Incorrect input texture dimensions. Expected: " + imgInfo.imgSize.ToString());
// check if images have same format type
if (!Methods.CheckTextureFormat(texFormat, imgFile.format))
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
throw new NotImplementedException("Texture replacement not supported in external packages yet");
case storage.pccSto:
imgBuffer = imgFile.resize();
using (MemoryStream dataStream = new MemoryStream())
{
dataStream.WriteBytes(imageData);
if (imgBuffer.Length <= imgInfo.uncSize && imgInfo.offset > 0)
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
else
imgInfo.offset = (int)dataStream.Position;
dataStream.WriteBytes(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
imgInfo.uncSize = imgBuffer.Length;
imageData = dataStream.ToArray();
}
break;
case storage.pccCpr:
using (MemoryStream dataStream = new MemoryStream())
{
dataStream.WriteBytes(imageData);
SaltLZOHelper lzohelper = new SaltLZOHelper();
imgBuffer = lzohelper.CompressTex(imgFile.resize());
if (imgBuffer.Length <= imgInfo.cprSize && imgInfo.offset > 0)
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
else
imgInfo.offset = (int)dataStream.Position;
dataStream.WriteBytes(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
imgInfo.uncSize = imgFile.resize().Length;
imageData = dataStream.ToArray();
}
break;
}
privateimgList[imageIdx] = imgInfo;
}
public void replaceImage(string strImgSize, ImageFile im, string archiveDir = null)
{
replaceImage(strImgSize, im, true, archiveDir);
}
public void singleImageUpscale(ImageFile im, string archiveDir)
{
ImageSize biggerImageSizeOnList = privateimgList.Max(image => image.imgSize);
// check if replacing image is supported
ImageFile imgFile = im;
if (!Methods.CheckTextureFormat(texFormat, imgFile.format))
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
// !!! warning, this method breaks consistency between imgList and imageData[] !!!
ImageInfo newImgInfo = new ImageInfo();
newImgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
newImgInfo.imgSize = imgFile.imgSize;
newImgInfo.uncSize = imgFile.resize().Length;
newImgInfo.cprSize = 0x00; // not yet filled
newImgInfo.offset = 0x00; // not yet filled
privateimgList.RemoveAt(0); // Remove old single image and add new one
privateimgList.Add(newImgInfo);
//now I let believe the program that I'm doing an image replace, saving lot of code ;)
replaceImage2(newImgInfo.imgSize.ToString(), im, archiveDir);
// update Sizes
properties["SizeX"].Value.IntValue = (int)newImgInfo.imgSize.width;
properties["SizeY"].Value.IntValue = (int)newImgInfo.imgSize.height;
}
public void OneImageToRuleThemAll(ImageFile im, string archiveDir, byte[] imgData)
{
string newTextureGroup = "";
OneImageToRuleThemAll(archiveDir, im, out newTextureGroup, imgData);
}
public void addBiggerImage(ImageFile im, string archiveDir)
{
ImageSize biggerImageSizeOnList = privateimgList.Max(image => image.imgSize);
// check if replacing image is supported
ImageFile imgFile = im;
if (!Methods.CheckTextureFormat(texFormat, imgFile.format))
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
// check if image to add is valid
if (biggerImageSizeOnList.width * 2 != imgFile.imgSize.width || biggerImageSizeOnList.height * 2 != imgFile.imgSize.height)
throw new FormatException("image size " + imgFile.imgSize + " isn't valid, must be " + new ImageSize(biggerImageSizeOnList.width * 2, biggerImageSizeOnList.height * 2));
if (privateimgList.Count <= 1)
throw new Exception("Unable to add image, texture must have more than one image present");
// !!! warning, this method breaks consistency between imgList and imageData[] !!!
ImageInfo newImgInfo = new ImageInfo();
newImgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
// for additional mipmaps keep them in external archive but only when
// texture allready have such property
if (properties.ContainsKey("TextureFileCacheName"))
newImgInfo.storageType = storage.arcCpr;
newImgInfo.imgSize = imgFile.imgSize;
newImgInfo.uncSize = imgFile.resize().Length;
newImgInfo.cprSize = 0x00; // not yet filled
newImgInfo.offset = 0x00; // not yet filled
privateimgList.Insert(0, newImgInfo); // insert new image on top of the list
//now I let believe the program that I'm doing an image replace, saving lot of code ;)
replaceImage(newImgInfo.imgSize.ToString(), im, archiveDir);
//updating num of images
numMipMaps++;
// update MipTailBaseIdx
int propVal = properties["MipTailBaseIdx"].Value.IntValue;
propVal++;
properties["MipTailBaseIdx"].Value.IntValue = propVal;
// update Sizes
properties["SizeX"].Value.IntValue = (int)newImgInfo.imgSize.width;
properties["SizeY"].Value.IntValue = (int)newImgInfo.imgSize.height;
}
public void replaceImage(string strImgSize, ImageFile im, string archiveDir)
{
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!imgList.Exists(img => img.imgSize == imgSize))
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
int imageIdx = privateImageList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateImageList[imageIdx];
ImageFile imgFile = im;
// check if images have same format type
if (texFormat != imgFile.format || texFormat.Contains("ATI") && imgFile.format.Contains("NormalMap") || texFormat.Contains("NormalMap") && imgFile.format.Contains("ATI"))
{
bool res = KFreonLib.Misc.Methods.DisplayYesNoDialogBox("Warning, replacing image has format " + imgFile.subtype() + " while original has " + texFormat + ", would you like to replace it anyway?", "Warning, different image format found");
if (res)
imgFile.format = texFormat;
else
return;
//throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
}
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = privateImageList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
string archivePath = archiveDir + "\\" + arcName + ".tfc";
if (!File.Exists(archivePath))
throw new FileNotFoundException("Texture archive not found in " + archivePath);
if (getFileFormat() == ".tga")
imgBuffer = imgFile.resize(); // shrink image to essential data
else
imgBuffer = imgFile.imgData;
if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
using (FileStream archiveStream = new FileStream(archivePath, FileMode.Append, FileAccess.Write))
{
int newOffset = (int)archiveStream.Position;
if (imgInfo.storageType == storage.arcCpr)
{
imgBuffer = ZBlock.Compress(imgBuffer);
/*byte[] compressed = ZBlock.Compress(imgBuffer);
archiveStream.Write(compressed, 0, compressed.Length);*/
imgInfo.cprSize = imgBuffer.Length;
}
//else
archiveStream.Write(imgBuffer, 0, imgBuffer.Length);
imgInfo.offset = newOffset;
}
break;
case storage.pccSto:
imgBuffer = imgFile.imgData; // copy image data as-is
if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
using (MemoryStream dataStream = new MemoryStream(imageData))
{
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
dataStream.Write(imgBuffer, 0, imgBuffer.Length);
}
break;
}
imgList[imageIdx] = imgInfo;
}
public void replaceImage(string strImgSize, ImageFile im, string archiveDir)
{
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!privateimgList.Exists(img => img.imgSize == imgSize))
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
int imageIdx = privateimgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateimgList[imageIdx];
ImageFile imgFile = im;
if (imgFile.imgSize.height != imgInfo.imgSize.height || imgFile.imgSize.width != imgInfo.imgSize.width)
throw new FormatException("Incorrect input texture dimensions. Expected: " + imgInfo.imgSize.ToString());
if (!Methods.CheckTextureFormat(texFormat, imgFile.format))
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
// overwrite previous choices for specific cases
if (properties.ContainsKey("NeverStream") && properties["NeverStream"].Value.IntValue == 1)
imgInfo.storageType = storage.pccSto;
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
string archivePath = FullArcPath;
if (String.IsNullOrEmpty(archivePath))
archivePath = GetTexArchive(archiveDir);
if (!File.Exists(archivePath))
throw new FileNotFoundException("Texture archive not found in " + archivePath);
if (getFileFormat() == ".tga")
imgBuffer = imgFile.resize(); // shrink image to essential data
else
imgBuffer = imgFile.imgData;
if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
if (arcName.Length <= CustCache.Length || arcName.Substring(0, CustCache.Length) != CustCache) // Check whether existing texture is in a custom cache
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
else
{
FileInfo arc = new FileInfo(archivePath);
if (arc.Length + imgBuffer.Length >= 0x80000000)
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
}
using (FileStream archiveStream = new FileStream(archivePath, FileMode.Append, FileAccess.Write))
{
int newOffset = (int)archiveStream.Position;
//archiveStream.Position = imgInfo.offset;
if (imgInfo.storageType == storage.arcCpr)
{
byte[] tempBuff;
SaltLZOHelper lzohelper = new SaltLZOHelper();
tempBuff = lzohelper.CompressTex(imgBuffer);
imgBuffer = new byte[tempBuff.Length];
Buffer.BlockCopy(tempBuff, 0, imgBuffer, 0, tempBuff.Length);
imgInfo.cprSize = imgBuffer.Length;
}
//else
archiveStream.Write(imgBuffer, 0, imgBuffer.Length);
imgInfo.offset = newOffset;
}
break;
case storage.pccSto:
//imgBuffer = imgFile.imgData; // copy image data as-is
imgBuffer = imgFile.resize();
using (MemoryStream dataStream = new MemoryStream())
{
dataStream.WriteBytes(imageData);
if (imgBuffer.Length <= imgInfo.uncSize && imgInfo.offset > 0)
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
else
imgInfo.offset = (int)dataStream.Position;
dataStream.WriteBytes(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
imgInfo.uncSize = imgBuffer.Length;
imageData = dataStream.ToArray();
}
break;
}
privateimgList[imageIdx] = imgInfo;
}
public void singleImageUpscale(ImageFile im, string archiveDir)
{
throw new NotImplementedException();
}
public void replaceImage2(string strImgSize, ImageFile im, string archiveDir)
{
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!privateimgList.Exists(img => img.imgSize == imgSize))
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
int imageIdx = privateimgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateimgList[imageIdx];
// check if replacing image is supported
ImageFile imgFile = im;
// check if images have same format type
if (texFormat != imgFile.format && texFormat != "G8")
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
//string archivePath = GetTexArchive(archiveDir);
string archivePath = FullArcPath;
if (String.IsNullOrEmpty(archivePath))
archivePath = GetTexArchive(archiveDir);
if (archivePath == null)
throw new FileNotFoundException("Teture archive not found!");
if (!File.Exists(archivePath))
throw new FileNotFoundException("Texture archive not found in " + archivePath);
if (getFileFormat() == ".tga")
imgBuffer = imgFile.resize(); // shrink image to essential data
else
imgBuffer = imgFile.imgData;
if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
if (arcName.Length <= CustCache.Length || arcName.Substring(0, CustCache.Length) != CustCache) // Check whether existing texture is in a custom cache
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
else
{
FileInfo arc = new FileInfo(archivePath);
if (arc.Length + imgBuffer.Length >= 0x80000000)
{
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = FullArcPath;
}
}
/* FileInfo arc = new FileInfo(archivePath);
if (arc.Length + imgBuffer.Length >= 0x80000000)
{
//2GB fix
ChooseNewCache(archiveDir, imgBuffer.Length);
archivePath = archiveDir + "\\" + arcName + ".tfc";
} */
using (FileStream archiveStream = new FileStream(archivePath, FileMode.Append, FileAccess.Write))
{
int newOffset = (int)archiveStream.Position;
if (imgInfo.storageType == storage.arcCpr)
{
imgBuffer = ZBlock.Compress(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
}
archiveStream.Write(imgBuffer, 0, imgBuffer.Length);
imgInfo.offset = newOffset;
}
break;
case storage.pccSto:
imgBuffer = imgFile.imgData; // copy image data as-is
/*if (imgBuffer.Length != imgInfo.uncSize)
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);*/
using (MemoryStream dataStream = new MemoryStream())
{
dataStream.WriteBytes(imageData);
if (imgBuffer.Length <= imgInfo.uncSize && imgInfo.offset > 0)
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
else
imgInfo.offset = (int)dataStream.Position;
dataStream.WriteBytes(imgBuffer);
imgInfo.cprSize = imgBuffer.Length;
imgInfo.uncSize = imgBuffer.Length;
imageData = dataStream.ToArray();
}
#region Old code
/*
try
{
using (MemoryStream dataStream = new MemoryStream(imageData))
{
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
dataStream.Write(imgBuffer, 0, imgBuffer.Length);
}
}
catch (NotSupportedException)
{
MemoryStream dataStream = new MemoryStream();
dataStream.WriteBytes(imgBuffer);
dataStream.WriteBytes(imageData);
imageData = dataStream.ToArray();
dataStream.Close();
for (int i = 1; i < imgList.Count; i++)
{
ImageInfo img = imgList[i];
img.offset += imgBuffer.Length;
imgList[i] = img;
}
}
*/
#endregion
break;
}
privateimgList[imageIdx] = imgInfo;
//this.hasChanged = true;
}
public void HardReplaceImage(ImageFile ddsfile)
{
ImageSize imgSize = ddsfile.imgSize;
if (ddsfile.format == "R8G8B8")
{
byte[] buff = ImageMipMapHandler.ConvertTo32bit(ddsfile.imgData, (int)ddsfile.imgSize.width, (int)ddsfile.imgSize.height);
ddsfile = new DDS(null, ddsfile.imgSize, "A8R8G8B8", buff);
}
ImageInfo newImg = new ImageInfo();
newImg.storageType = imgList[0].storageType;
if (newImg.storageType == storage.empty || newImg.storageType == storage.arcCpr || newImg.storageType == storage.arcUnc)
throw new FormatException("Original texture cannot be empty or externally stored");
newImg.offset = 0;
newImg.imgSize = imgSize;
imageData = ddsfile.resize();
newImg.uncSize = imageData.Length;
if ((long)newImg.uncSize != ImageFile.ImageDataSize(imgSize, ddsfile.format, ddsfile.BPP))
throw new FormatException("Input texture not correct length!");
switch (newImg.storageType)
{
case storage.pccSto:
newImg.cprSize = imageData.Length;
break;
case storage.pccCpr:
SaltLZOHelper lzohelper = new SaltLZOHelper();
imageData = lzohelper.CompressTex(imageData);
newImg.cprSize = imageData.Length;
break;
}
imgList.RemoveAt(0);
imgList.Add(newImg);
// Fix up properties
properties["SizeX"].Value.IntValue = (int)imgSize.width;
properties["SizeY"].Value.IntValue = (int)imgSize.height;
}
public void singleImageUpscale(ImageFile im, string archiveDir)
{
ImageSize biggerImageSizeOnList = privateimgList.Max(image => image.imgSize);
// check if replacing image is supported
ImageFile imgFile = im;
ImageEngineFormat imageFileFormat = Textures.Methods.ParseFormat(imgFile.format);
//NEW Check for correct image format
if (texFormat != imageFileFormat)
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
// !!! warning, this method breaks consistency between imgList and imageData[] !!!
ImageInfo newImgInfo = new ImageInfo();
newImgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
newImgInfo.imgSize = imgFile.imgSize;
newImgInfo.uncSize = imgFile.resize().Length;
newImgInfo.cprSize = 0x00; // not yet filled
newImgInfo.offset = 0x00; // not yet filled
//imgList.Insert(0, newImgInfo); // insert new image on top of the list
privateimgList.RemoveAt(0); // Remove old single image and add new one
privateimgList.Add(newImgInfo);
//now I let believe the program that I'm doing an image replace, saving lot of code ;)
replaceImage2(newImgInfo.imgSize.ToString(), im, archiveDir);
// update Sizes
//PropertyReader.Property Size = properties["SizeX"];
int propVal = (int)newImgInfo.imgSize.width;
properties["SizeX"].Value.IntValue = propVal;
using (MemoryStream rawStream = new MemoryStream(properties["SizeX"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["SizeX"].raw = rawStream.ToArray();
}
//properties["SizeX"] = Size;
//Size = properties["SizeY"];
properties["SizeY"].Value.IntValue = (int)newImgInfo.imgSize.height;
using (MemoryStream rawStream = new MemoryStream(properties["SizeY"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["SizeY"].raw = rawStream.ToArray();
}
//properties["SizeY"] = Size;
properties["OriginalSizeX"].Value.IntValue = propVal;
using (MemoryStream rawStream = new MemoryStream(properties["OriginalSizeX"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["OriginalSizeX"].raw = rawStream.ToArray();
}
properties["OriginalSizeY"].Value.IntValue = propVal;
using (MemoryStream rawStream = new MemoryStream(properties["OriginalSizeY"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["OriginalSizeY"].raw = rawStream.ToArray();
}
//this.hasChanged = true;
}
public void ReplaceImage(ImageFile ddsfile)
{
ImageSize imgSize = ddsfile.imgSize;
int imageIdx = imgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = imgList[imageIdx];
if (imgInfo.storageType == storage.empty && imgInfo.imgSize.width > imgList.First(img => img.storageType != storage.empty).imgSize.width)
imgInfo.storageType = imgList.First(img => img.storageType != storage.empty).storageType;
else if (imgInfo.storageType == storage.empty)
imgInfo.storageType = imgList.Last(img => img.storageType != storage.empty).storageType;
if (imgInfo.storageType == storage.arcCpr || imgInfo.storageType == storage.arcUnc)
throw new FormatException("Replacement of externally stored textures is not allowed");
else if (imgInfo.storageType == storage.empty)
throw new FormatException("Cannot replace images with empty image lists");
byte[] imgBuff = ddsfile.resize();
using (MemoryStream ms = new MemoryStream())
{
ms.WriteBytes(imageData);
imgInfo.uncSize = imgBuff.Length;
if ((long)imgInfo.uncSize != ImageFile.ImageDataSize(ddsfile.imgSize, ddsfile.format, ddsfile.BPP))
throw new FormatException("Input texture not correct length!");
if (imgInfo.storageType == storage.pccCpr)
{
SaltLZOHelper lzo = new SaltLZOHelper();
imgBuff = lzo.CompressTex(imgBuff);
}
if (imgBuff.Length <= imgInfo.cprSize && imgInfo.offset > 0)
ms.Seek(imgInfo.offset, SeekOrigin.Begin);
else
imgInfo.offset = (int)ms.Position;
imgInfo.cprSize = imgBuff.Length;
ms.WriteBytes(imgBuff);
imageData = ms.ToArray();
}
imgList[imageIdx] = imgInfo;
}
public void addBiggerImage(ImageFile im, string archiveDir)
{
//DebugOutput.PrintLn( "\nIn Addbiggerimage...\n");
ImageSize biggerImageSizeOnList = privateimgList.Max(image => image.imgSize);
// check if replacing image is supported
ImageFile imgFile = im;
ImageEngineFormat imgFileFormat = Textures.Methods.ParseFormat(imgFile.format);
//NEW Check for correct image format
if (texFormat != imgFileFormat)
throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
// check if image to add is valid
if (biggerImageSizeOnList.width * 2 != imgFile.imgSize.width || biggerImageSizeOnList.height * 2 != imgFile.imgSize.height)
throw new FormatException("image size " + imgFile.imgSize + " isn't valid, must be " + new ImageSize(biggerImageSizeOnList.width * 2, biggerImageSizeOnList.height * 2));
// this check avoids insertion inside textures that have only 1 image stored inside pcc
if (privateimgList.Count <= 1)
throw new Exception("Unable to add image, texture must have more than one existing image");
// !!! warning, this method breaks consistency between imgList and imageData[] !!!
ImageInfo newImgInfo = new ImageInfo();
newImgInfo.storageType = privateimgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
newImgInfo.imgSize = imgFile.imgSize;
newImgInfo.uncSize = imgFile.resize().Length;
newImgInfo.cprSize = 0x00; // not yet filled
newImgInfo.offset = 0x00; // not yet filled
privateimgList.Insert(0, newImgInfo); // insert new image on top of the list
//now I let believe the program that I'm doing an image replace, saving lot of code ;)
replaceImage(newImgInfo.imgSize.ToString(), im, archiveDir);
//updating num of images
numMipMaps++;
// update MipTailBaseIdx
//PropertyReader.Property MipTail = properties["MipTailBaseIdx"];
int propVal = properties["MipTailBaseIdx"].Value.IntValue;
propVal++;
properties["MipTailBaseIdx"].Value.IntValue = propVal;
//MessageBox.Show("raw size: " + properties["MipTailBaseIdx"].raw.Length + "\nproperty offset: " + properties["MipTailBaseIdx"].offsetval);
using (MemoryStream rawStream = new MemoryStream(properties["MipTailBaseIdx"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propVal);
properties["MipTailBaseIdx"].raw = rawStream.ToArray();
}
//properties["MipTailBaseIdx"] = MipTail;
// update Sizes
//PropertyReader.Property Size = properties["SizeX"];
// Heff: Fixed(?) to account for non-square images
int propX = (int)newImgInfo.imgSize.width;
int propY = (int)newImgInfo.imgSize.height;
properties["SizeX"].Value.IntValue = propX;
using (MemoryStream rawStream = new MemoryStream(properties["SizeX"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propX);
properties["SizeX"].raw = rawStream.ToArray();
}
//properties["SizeX"] = Size;
//Size = properties["SizeY"];
properties["SizeY"].Value.IntValue = propY;
using (MemoryStream rawStream = new MemoryStream(properties["SizeY"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propY);
properties["SizeY"].raw = rawStream.ToArray();
}
//properties["SizeY"] = Size;
try
{
properties["OriginalSizeX"].Value.IntValue = propX;
using (MemoryStream rawStream = new MemoryStream(properties["OriginalSizeX"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propX);
properties["OriginalSizeX"].raw = rawStream.ToArray();
}
properties["OriginalSizeY"].Value.IntValue = propY;
using (MemoryStream rawStream = new MemoryStream(properties["OriginalSizeY"].raw))
{
rawStream.Seek(rawStream.Length - 4, SeekOrigin.Begin);
rawStream.WriteValueS32(propY);
properties["OriginalSizeY"].raw = rawStream.ToArray();
}
}
catch
{
// Some lightmaps don't have these properties. I'm ignoring them cos I'm ignorant. KFreon.
}
//this.hasChanged = true;
}
/// <summary>
/// Load an image into one of AK86's classes.
/// </summary>
/// <param name="im">AK86 image already, just return it unless null. Then load from fileToLoad.</param>
/// <param name="fileToLoad">Path to file to be loaded. Irrelevent if im is provided.</param>
/// <returns>AK86 Image file.</returns>
public static ImageFile LoadAKImageFile(ImageFile im, string fileToLoad)
{
ImageFile imgFile = null;
if (im != null)
imgFile = im;
else
{
if (!File.Exists(fileToLoad))
throw new FileNotFoundException("invalid file to replace: " + fileToLoad);
// check if replacing image is supported
string fileFormat = Path.GetExtension(fileToLoad);
switch (fileFormat)
{
case ".dds": imgFile = new DDS(fileToLoad, null); break;
case ".tga": imgFile = new TGA(fileToLoad, null); break;
default: throw new FileNotFoundException(fileFormat + " image extension not supported");
}
}
return imgFile;
}
