public ME1PCCObject(String path, MemoryStream tempStream)
{
lzo = new SaltLZOHelper();
fullname = path;
BitConverter.IsLittleEndian = true;
DebugOutput.PrintLn("Load file : " + path);
pccFileName = Path.GetFullPath(path);
LoadHelper(tempStream);
}
public ME1PCCObject(String path)
{
lzo = new SaltLZOHelper();
fullname = path;
BitConverter.IsLittleEndian = true;
DebugOutput.PrintLn("Load file : " + path);
pccFileName = Path.GetFullPath(path);
MemoryStream tempStream = new MemoryStream();
if (!File.Exists(pccFileName))
throw new FileNotFoundException("PCC file not found");
using (FileStream fs = new FileStream(pccFileName, FileMode.Open, FileAccess.Read))
{
FileInfo tempInfo = new FileInfo(pccFileName);
tempStream.WriteFromStream(fs, tempInfo.Length);
if (tempStream.Length != tempInfo.Length)
{
throw new FileLoadException("File not fully read in. Try again later");
}
}
LoadHelper(tempStream);
}
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 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 byte[] extractImage(ImageInfo imgInfo, bool NoOutput, string archiveDir = null, string fileName = null)
{
ImageFile imgFile;
if (fileName == null)
{
fileName = texName + "_" + imgInfo.imgSize + getFileFormat();
}
byte[] imgBuffer = null;
switch (imgInfo.storageType)
{
case storage.pccSto:
imgBuffer = new byte[imgInfo.uncSize];
Buffer.BlockCopy(imageData, imgInfo.offset, imgBuffer, 0, imgInfo.uncSize);
break;
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);
}
using (FileStream archiveStream = File.OpenRead(archivePath))
{
if (imgInfo.storageType == storage.arcCpr)
{
SaltLZOHelper lzohelp = new SaltLZOHelper();
imgBuffer = lzohelp.DecompressTex(archiveStream, imgInfo.offset, imgInfo.uncSize, imgInfo.cprSize);
}
else
{
archiveStream.Seek(imgInfo.offset, SeekOrigin.Begin);
imgBuffer = new byte[imgInfo.uncSize];
archiveStream.Read(imgBuffer, 0, imgBuffer.Length);
}
}
break;
default:
throw new FormatException("Unsupported texture storage type");
}
imgFile = new DDS(fileName, imgInfo.imgSize, texFormat, imgBuffer);
byte[] saveImg = imgFile.ToArray();
if (!NoOutput)
using (FileStream outputImg = new FileStream(imgFile.fileName, FileMode.Create, FileAccess.Write))
outputImg.Write(saveImg, 0, saveImg.Length);
return saveImg;
}
public void DumpImageData(ImageInfo imgInfo, string archiveDir = null, string fileName = null)
{
if (fileName == null)
{
fileName = texName + "_" + imgInfo.imgSize + ".bin";
}
byte[] imgBuffer;
switch (imgInfo.storageType)
{
case storage.pccSto:
imgBuffer = new byte[imgInfo.uncSize];
Buffer.BlockCopy(imageData, imgInfo.offset, imgBuffer, 0, imgInfo.uncSize);
break;
case storage.arcCpr:
case storage.arcUnc:
string archivePath = FullArcPath;
if (String.IsNullOrEmpty(archivePath))
GetTexArchive(archiveDir);
if (!File.Exists(archivePath))
{
throw new FileNotFoundException("Texture archive not found in " + archivePath);
}
using (FileStream archiveStream = File.OpenRead(archivePath))
{
//archiveStream.Seek(imgInfo.offset, SeekOrigin.Begin);
if (imgInfo.storageType == storage.arcCpr)
{
SaltLZOHelper lzohelp = new SaltLZOHelper();
imgBuffer = lzohelp.DecompressTex(archiveStream, imgInfo.offset, imgInfo.uncSize, imgInfo.cprSize);
}
else
{
archiveStream.Seek(imgInfo.offset, SeekOrigin.Begin);
imgBuffer = new byte[imgInfo.uncSize];
archiveStream.Read(imgBuffer, 0, imgBuffer.Length);
}
}
break;
default:
throw new FormatException("Unsupported texture storage type");
}
using (FileStream outputImg = new FileStream(fileName, FileMode.Create, FileAccess.Write))
outputImg.Write(imgBuffer, 0, imgBuffer.Length);
}
public byte[] DumpImage(ImageSize imgSize, string archiveDir)
{
byte[] imgBuff = null;
ImageInfo imgInfo;
if (privateimgList.Exists(img => img.imgSize == imgSize))
imgInfo = privateimgList.Find(img => img.imgSize == imgSize);
else
throw new FileNotFoundException("Image with resolution " + imgSize + " not found");
switch (imgInfo.storageType)
{
case storage.pccSto:
imgBuff = new byte[imgInfo.uncSize];
Buffer.BlockCopy(imageData, imgInfo.offset, imgBuff, 0, imgInfo.uncSize);
break;
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);
using (FileStream archiveStream = File.OpenRead(archivePath))
{
if (imgInfo.storageType == storage.arcCpr)
{
SaltLZOHelper lzohelp = new SaltLZOHelper();
imgBuff = lzohelp.DecompressTex(archiveStream, imgInfo.offset, imgInfo.uncSize, imgInfo.cprSize);
}
else
{
archiveStream.Seek(imgInfo.offset, SeekOrigin.Begin);
imgBuff = new byte[imgInfo.uncSize];
archiveStream.Read(imgBuff, 0, imgBuff.Length);
}
}
break;
default:
throw new FormatException("Unsupported texture storage type");
}
return imgBuff;
}
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 = privateimgList[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;
}
privateimgList.RemoveAt(0);
privateimgList.Add(newImg);
// Fix up properties
properties["SizeX"].Value.IntValue = (int)imgSize.width;
properties["SizeY"].Value.IntValue = (int)imgSize.height;
}
public byte[] extractImage(ImageInfo imgInfo, bool NoOutput, string archiveDir = null, string fileName = null)
{
ImageFile imgFile;
if (fileName == null)
fileName = texName + "_" + imgInfo.imgSize + getFileFormat();
byte[] imgBuffer = null;
switch (imgInfo.storageType)
{
case storage.pccSto:
imgBuffer = new byte[imgInfo.uncSize];
Buffer.BlockCopy(imageData, imgInfo.offset, imgBuffer, 0, imgInfo.uncSize);
break;
case storage.arcCpr:
case storage.arcUnc:
string archivePath = FindFile();
if (String.IsNullOrEmpty(archivePath))
throw new FileNotFoundException();
ME1PCCObject temp = new ME1PCCObject(archivePath);
for (int i = 0; i < temp.ExportCount; i++)
{
if (String.Compare(texName, temp.Exports[i].ObjectName, true) == 0 && temp.Exports[i].ValidTextureClass())
{
ME1Texture2D temptex = new ME1Texture2D(temp, i);
imgBuffer = temptex.extractImage(imgInfo.imgSize.ToString(), NoOutput, null, fileName);
// temptex.extractImage(imgInfo.imgSize.ToString(), temp, null, fileName);
}
}
break;
case storage.pccCpr:
using (MemoryStream ms = new MemoryStream(imageData))
{
SaltLZOHelper lzohelp = new SaltLZOHelper();
imgBuffer = lzohelp.DecompressTex(ms, imgInfo.offset, imgInfo.uncSize, imgInfo.cprSize);
}
break;
default:
throw new FormatException("Unsupported texture storage type");
}
if (imgInfo.storageType == storage.pccSto || imgInfo.storageType == storage.pccCpr)
{
if (getFileFormat() == ".dds")
imgFile = new DDS(fileName, imgInfo.imgSize, texFormat, imgBuffer);
else
imgFile = new TGA(fileName, imgInfo.imgSize, texFormat, imgBuffer);
byte[] saveImg = imgFile.ToArray();
if (!NoOutput)
using (FileStream outputImg = new FileStream(imgFile.fileName, FileMode.Create, FileAccess.Write))
outputImg.Write(saveImg, 0, saveImg.Length);
return saveImg;
}
return imgBuffer;
}
public byte[] DumpImage(ImageSize imgSize)
{
byte[] imgBuffer = null;
ImageInfo imgInfo;
if (privateimgList.Exists(img => (img.imgSize == imgSize && img.cprSize != -1)))
imgInfo = privateimgList.Find(img => img.imgSize == imgSize);
else
//throw new FileNotFoundException("Image with resolution " + imgSize + " not found");
return null;
switch (imgInfo.storageType)
{
case storage.pccSto:
imgBuffer = new byte[imgInfo.uncSize];
Buffer.BlockCopy(imageData, imgInfo.offset, imgBuffer, 0, imgInfo.uncSize);
break;
case storage.arcCpr:
case storage.arcUnc:
string archivePath = FindFile();
if (String.IsNullOrEmpty(archivePath))
throw new FileNotFoundException();
ME1PCCObject temp = new ME1PCCObject(archivePath);
for (int i = 0; i < temp.ExportCount; i++)
{
if (String.Compare(texName, temp.Exports[i].ObjectName, true) == 0 && (temp.Exports[i].ClassName == "Texture2D"))// || temp.Exports[i].ClassName == "TextureFlipBook"))
{
ME1Texture2D temptex = new ME1Texture2D(temp, i);
/*if (imgSize.width > dims)
{
dims = (int) imgSize.width;*/
byte[] temp1 = temptex.DumpImage(imgSize);
if (temp1 != null)
imgBuffer = temp1;
//}
}
}
break;
case storage.pccCpr:
using (MemoryStream ms = new MemoryStream(imageData))
{
SaltLZOHelper lzohelp = new SaltLZOHelper();
imgBuffer = lzohelp.DecompressTex(ms, imgInfo.offset, imgInfo.uncSize, imgInfo.cprSize);
}
break;
default:
throw new FormatException("Unsupported texture storage type");
imgBuffer = null;
break;
}
return imgBuffer;
}
public void CopyImgList(ME1Texture2D inTex, ME1PCCObject pcc, bool norender = false)
{
List<ImageInfo> tempList = new List<ImageInfo>();
MemoryStream tempData = new MemoryStream();
SaltLZOHelper lzo = new SaltLZOHelper();
numMipMaps = inTex.numMipMaps;
// forced norenderfix
// norender = true;
int type = -1;
if (!norender)
{
if (privateimgList.Exists(img => img.storageType == storage.arcCpr) && privateimgList.Count > 1)
type = 1;
else if (privateimgList.Exists(img => img.storageType == storage.pccCpr))
type = 2;
else if (privateimgList.Exists(img => img.storageType == storage.pccSto) || privateimgList.Count == 1)
type = 3;
}
else
type = 3;
switch (type)
{
case 1:
for (int i = 0; i < inTex.privateimgList.Count; i++)
{
try
{
ImageInfo newImg = new ImageInfo();
ImageInfo replaceImg = inTex.privateimgList[i];
ME1Texture2D.storage replaceType = privateimgList.Find(img => img.imgSize == replaceImg.imgSize).storageType;
int j = 0;
while (replaceType == storage.empty)
{
j++;
replaceType = privateimgList[privateimgList.FindIndex(img => img.imgSize == replaceImg.imgSize) + j].storageType;
}
if (replaceType == storage.arcCpr || !privateimgList.Exists(img => img.imgSize == replaceImg.imgSize))
{
newImg.storageType = storage.arcCpr;
newImg.uncSize = replaceImg.uncSize;
newImg.cprSize = replaceImg.cprSize;
newImg.imgSize = replaceImg.imgSize;
newImg.offset = (int)(replaceImg.offset + inTex.pccOffset + inTex.dataOffset);
}
else
{
newImg.storageType = storage.pccSto;
newImg.uncSize = replaceImg.uncSize;
newImg.cprSize = replaceImg.uncSize;
newImg.imgSize = replaceImg.imgSize;
newImg.offset = (int)(tempData.Position);
using (MemoryStream tempStream = new MemoryStream(inTex.imageData))
{
tempData.WriteBytes(lzo.DecompressTex(tempStream, replaceImg.offset, replaceImg.uncSize, replaceImg.cprSize));
}
}
tempList.Add(newImg);
}
catch
{
ImageInfo replaceImg = inTex.privateimgList[i];
if (!privateimgList.Exists(img => img.imgSize == replaceImg.imgSize))
throw new Exception("An error occurred during imglist copying and no suitable replacement was found");
ImageInfo newImg = privateimgList.Find(img => img.imgSize == replaceImg.imgSize);
if (newImg.storageType != storage.pccCpr && newImg.storageType != storage.pccSto)
throw new Exception("An error occurred during imglist copying and no suitable replacement was found");
int temppos = newImg.offset;
newImg.offset = (int)tempData.Position;
tempData.Write(imageData, temppos, newImg.cprSize);
tempList.Add(newImg);
}
}
break;
case 2:
for (int i = 0; i < inTex.privateimgList.Count; i++)
{
ImageInfo newImg = new ImageInfo();
ImageInfo replaceImg = inTex.privateimgList[i];
newImg.storageType = storage.pccCpr;
newImg.uncSize = replaceImg.uncSize;
newImg.cprSize = replaceImg.cprSize;
newImg.imgSize = replaceImg.imgSize;
newImg.offset = (int)(tempData.Position);
byte[] buffer = new byte[newImg.cprSize];
Buffer.BlockCopy(inTex.imageData, replaceImg.offset, buffer, 0, buffer.Length);
tempData.WriteBytes(buffer);
tempList.Add(newImg);
}
break;
case 3:
for (int i = 0; i < inTex.privateimgList.Count; i++)
{
ImageInfo newImg = new ImageInfo();
ImageInfo replaceImg = inTex.privateimgList[i];
newImg.storageType = storage.pccSto;
newImg.uncSize = replaceImg.uncSize;
newImg.cprSize = replaceImg.uncSize;
newImg.imgSize = replaceImg.imgSize;
newImg.offset = (int)(tempData.Position);
if (replaceImg.storageType == storage.pccCpr)
{
using (MemoryStream tempStream = new MemoryStream(inTex.imageData))
{
tempData.WriteBytes(lzo.DecompressTex(tempStream, replaceImg.offset, replaceImg.uncSize, replaceImg.cprSize));
}
}
else if (replaceImg.storageType == storage.pccSto)
{
byte[] buffer = new byte[newImg.cprSize];
Buffer.BlockCopy(inTex.imageData, replaceImg.offset, buffer, 0, buffer.Length);
tempData.WriteBytes(buffer);
}
else
throw new NotImplementedException("Copying from non package stored texture no available");
tempList.Add(newImg);
}
break;
default:
throw new NotImplementedException();
}
for (int i = 0; i < tempList.Count; i++)
{
ImageInfo tempinfo = tempList[i];
if (inTex.privateimgList[i].storageType == storage.empty)
tempinfo.storageType = storage.empty;
tempList[i] = tempinfo;
}
privateimgList = tempList;
imageData = tempData.ToArray();
tempData.Close();
byte[] buff;
//Copy properties
using (MemoryStream tempMem = new MemoryStream())
{
tempMem.WriteBytes(headerData);
for (int i = 0; i < inTex.properties.Count; i++)
{
SaltPropertyReader.Property prop = inTex.properties.ElementAt(i).Value;
if (prop.Name == "UnpackMin")
{
for (int j = 0; j < inTex.UnpackNum; j++)
{
tempMem.WriteValueS64(pcc.AddName(prop.Name));
tempMem.WriteValueS64(pcc.AddName(prop.TypeVal.ToString()));
tempMem.WriteValueS32(prop.Size);
tempMem.WriteValueS32(j);
tempMem.WriteValueF32(prop.Value.FloatValue, Endian.Little);
}
continue;
}
tempMem.WriteValueS64(pcc.AddName(prop.Name));
if (prop.Name == "None")
{
for (int j = 0; j < 12; j++)
tempMem.WriteByte(0);
}
else
{
tempMem.WriteValueS64(pcc.AddName(prop.TypeVal.ToString()));
tempMem.WriteValueS64(prop.Size);
switch (prop.TypeVal)
{
case SaltPropertyReader.Type.IntProperty:
tempMem.WriteValueS32(prop.Value.IntValue);
break;
case SaltPropertyReader.Type.BoolProperty:
tempMem.Seek(-4, SeekOrigin.Current);
tempMem.WriteValueS32(prop.Value.IntValue);
tempMem.Seek(4, SeekOrigin.Current);
break;
case SaltPropertyReader.Type.NameProperty:
tempMem.WriteValueS64(pcc.AddName(prop.Value.StringValue));
// Heff: Modified to handle name references.
//var index = pcc.AddName(prop.Value.StringValue);
//tempMem.WriteValueS32(index);
//tempMem.WriteValueS32(prop.Value.NameValue.count);
break;
case SaltPropertyReader.Type.StrProperty:
tempMem.WriteValueS32(prop.Value.StringValue.Length + 1);
foreach (char c in prop.Value.StringValue)
tempMem.WriteByte((byte)c);
tempMem.WriteByte(0);
break;
case SaltPropertyReader.Type.StructProperty:
tempMem.WriteValueS64(pcc.AddName(prop.Value.StringValue));
foreach (SaltPropertyReader.PropertyValue value in prop.Value.Array)
tempMem.WriteValueS32(value.IntValue);
break;
case SaltPropertyReader.Type.ByteProperty:
tempMem.WriteValueS32(pcc.AddName(prop.Value.StringValue));
tempMem.WriteValueS32(prop.Value.IntValue);
break;
case SaltPropertyReader.Type.FloatProperty:
tempMem.WriteValueF32(prop.Value.FloatValue, Endian.Little);
break;
default:
throw new FormatException("unknown property");
}
}
}
buff = tempMem.ToArray();
}
int propertiesOffset = SaltPropertyReader.detectStart(pcc, buff);
headerData = new byte[propertiesOffset];
Buffer.BlockCopy(buff, 0, headerData, 0, propertiesOffset);
properties = new Dictionary<string, SaltPropertyReader.Property>();
List<SaltPropertyReader.Property> tempProperties = SaltPropertyReader.getPropList(pcc, buff);
UnpackNum = 0;
for (int i = 0; i < tempProperties.Count; i++)
{
SaltPropertyReader.Property property = tempProperties[i];
if (property.Name == "UnpackMin")
UnpackNum++;
if (!properties.ContainsKey(property.Name))
properties.Add(property.Name, property);
switch (property.Name)
{
case "Format": texFormat = property.Value.StringValue; break;
case "LODGroup": LODGroup = property.Value.StringValue; break;
case "CompressionSettings": Compression = property.Value.StringValue; break;
case "None": dataOffset = (uint)(property.offsetval + property.Size); break;
}
}
// if "None" property isn't found throws an exception
if (dataOffset == 0)
throw new Exception("\"None\" property not found");
}
public void addMissingImage(String strImgSize, string fileToReplace)
{
if (privateimgList.Count == 1)
throw new Exception("The imglist must contain more than 1 texture");
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (privateimgList.Exists(img => img.imgSize.width == imgSize.width && img.imgSize.height == imgSize.height))
throw new Exception("The img already exists in the list");
ImageInfo tempImg = privateimgList.Last();
if (!File.Exists(fileToReplace))
throw new FileNotFoundException("Required file was not found");
ImageFile dds = new DDS(fileToReplace, null);
if (dds.imgSize.width != imgSize.width || dds.imgSize.height != imgSize.height)
throw new FormatException("Input texture is not required size");
if (dds.format == "R8G8B8")
{
byte[] buff = ImageMipMapHandler.ConvertTo32bit(dds.imgData, (int)dds.imgSize.width, (int)dds.imgSize.height);
dds = new DDS(null, dds.imgSize, "A8R8G8B8", buff);
}
if (texFormat == "PF_NormalMap_HQ")
{
if (dds.format != "ATI2")
throw new FormatException("Input texture is the wrong format");
}
else if (String.Compare(texFormat, "PF_" + dds.format, true) != 0 && String.Compare(texFormat, dds.format, true) != 0)
throw new FormatException("Input texture is the wrong format");
ImageInfo newImg = new ImageInfo();
if (tempImg.storageType == storage.empty || tempImg.storageType == storage.arcCpr || tempImg.storageType == storage.arcUnc)
throw new FormatException("Existing textures cannot be empty or externally stored");
newImg.storageType = tempImg.storageType;
newImg.imgSize = imgSize;
using (MemoryStream ms = new MemoryStream())
{
ms.WriteBytes(imageData);
newImg.offset = (int)ms.Position;
switch (newImg.storageType)
{
case storage.pccSto:
ms.WriteBytes(dds.resize());
//newImg.cprSize = dds.imgData.Length;
//newImg.uncSize = dds.imgData.Length;
newImg.cprSize = dds.resize().Length;
newImg.uncSize = dds.resize().Length;
break;
case storage.pccCpr:
SaltLZOHelper lzohelper = new SaltLZOHelper();
//byte[] buff = lzohelper.CompressTex(dds.imgData);
byte[] buff = lzohelper.CompressTex(dds.resize());
ms.WriteBytes(buff);
//newImg.uncSize = dds.imgData.Length;
newImg.uncSize = dds.resize().Length;
newImg.cprSize = buff.Length;
break;
}
imageData = ms.ToArray();
}
int i = 0;
for (; i < privateimgList.Count; i++)
{
if (privateimgList[i].imgSize.width > imgSize.width)
continue;
privateimgList.Insert(i, newImg);
return;
}
privateimgList.Insert(i, newImg);
if (ImageMipMapHandler.CprFormat(dds.format) && (newImg.imgSize.width < 4 || newImg.imgSize.height < 4))
{
newImg = privateimgList[i];
if (newImg.imgSize.width < 4 && newImg.imgSize.height > 4)
{
newImg.imgSize = new ImageSize(4, newImg.imgSize.height);
}
else if (newImg.imgSize.width > 4 && newImg.imgSize.height < 4)
{
newImg.imgSize = new ImageSize(newImg.imgSize.width, 4);
}
else if (newImg.imgSize.width < 4 && newImg.imgSize.height < 4)
{
newImg.imgSize = new ImageSize(4, 4);
}
else
throw new Exception("safety catch");
privateimgList[i] = newImg;
}
//throw new Exception("Newimg wasn't inserted in list!");
}
public void ReplaceImage(ImageFile ddsfile)
{
ImageSize imgSize = ddsfile.imgSize;
int imageIdx = privateimgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateimgList[imageIdx];
if (imgInfo.storageType == storage.empty && imgInfo.imgSize.width > privateimgList.First(img => img.storageType != storage.empty).imgSize.width)
imgInfo.storageType = privateimgList.First(img => img.storageType != storage.empty).storageType;
else if (imgInfo.storageType == storage.empty)
imgInfo.storageType = privateimgList.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();
}
privateimgList[imageIdx] = imgInfo;
}
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;
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
if (Exports != null)
{
try
{
foreach (ME1ExportEntry entry in Exports)
entry.Dispose();
}
catch { }
}
if (iexports != null)
{
try
{
foreach (ME1ExportEntry entry in iexports)
entry.Dispose();
}
catch { }
}
if (iimports != null)
{
try
{
foreach (ME1ImportEntry entry in iimports)
entry.Dispose();
}
catch { }
}
if (Imports != null)
{
try
{
foreach (ME1ImportEntry entry in Imports)
entry.Dispose();
}
catch { }
}
if (listsStream != null)
try
{
listsStream.Dispose();
}
catch { }
if (m != null)
try
{
m.Dispose();
}
catch { }
}
this.Names = null;
this.header = null;
this.lzo = null;
disposedValue = true;
}
}
public void CopyImgList(ME2Texture2D inTex, ME2PCCObject pcc)
{
numMipMaps = inTex.numMipMaps;
if (properties.ContainsKey("NeverStream") && properties["NeverStream"].Value.IntValue == 1)
{
imageData = null;
GC.Collect();
// store images as pccSto format
privateimgList = new List<ImageInfo>();
MemoryStream tempData = new MemoryStream();
for (int i = 0; i < inTex.privateimgList.Count; i++)
{
ImageInfo newImg = new ImageInfo();
ImageInfo replaceImg = inTex.privateimgList[i];
newImg.storageType = storage.pccSto;
newImg.uncSize = replaceImg.uncSize;
newImg.cprSize = replaceImg.uncSize;
newImg.imgSize = replaceImg.imgSize;
newImg.offset = (int)(tempData.Position);
if (replaceImg.storageType == storage.arcCpr)
{
string archivePath = inTex.FullArcPath;
if (!File.Exists(archivePath))
throw new FileNotFoundException("Texture archive not found in " + archivePath);
using (FileStream archiveStream = File.OpenRead(archivePath))
{
archiveStream.Seek(replaceImg.offset, SeekOrigin.Begin);
SaltLZOHelper lzohelp = new SaltLZOHelper();
tempData.WriteBytes(lzohelp.DecompressTex(archiveStream, replaceImg.offset, replaceImg.uncSize, replaceImg.cprSize));
}
}
else if (replaceImg.storageType == storage.pccSto)
{
byte[] buffer = new byte[newImg.cprSize];
Buffer.BlockCopy(inTex.imageData, replaceImg.offset, buffer, 0, buffer.Length);
tempData.WriteBytes(buffer);
}
else
throw new NotImplementedException("Copying from non package stored texture no available");
privateimgList.Add(newImg);
}
for (int i = 0; i < privateimgList.Count; i++)
{
ImageInfo tempinfo = privateimgList[i];
if (inTex.privateimgList[i].storageType == storage.empty)
tempinfo.storageType = storage.empty;
privateimgList[i] = tempinfo;
}
imageData = tempData.ToArray();
tempData.Close();
tempData = null;
GC.Collect();
}
else
{
imageData = inTex.imageData;
privateimgList = inTex.privateimgList;
}
// add properties "TextureFileCacheName" and "TFCFileGuid" if they are missing,
if (!properties.ContainsKey("TextureFileCacheName") && inTex.properties.ContainsKey("TextureFileCacheName"))
{
SaltPropertyReader.Property none = properties["None"];
properties.Remove("None");
SaltPropertyReader.Property property = new SaltPropertyReader.Property();
property.TypeVal = SaltPropertyReader.Type.NameProperty;
property.Name = "TextureFileCacheName";
property.Size = 8;
SaltPropertyReader.PropertyValue value = new SaltPropertyReader.PropertyValue();
value.StringValue = "Textures";
property.Value = value;
properties.Add("TextureFileCacheName", property);
arcName = value.StringValue;
if (!properties.ContainsKey("TFCFileGuid"))
{
SaltPropertyReader.Property guidprop = new SaltPropertyReader.Property();
guidprop.TypeVal = SaltPropertyReader.Type.StructProperty;
guidprop.Name = "TFCFileGuid";
guidprop.Size = 16;
SaltPropertyReader.PropertyValue guid = new SaltPropertyReader.PropertyValue();
guid.len = guidprop.Size;
guid.StringValue = "Guid";
guid.IntValue = pcc.AddName(guid.StringValue);
guid.Array = new List<SaltPropertyReader.PropertyValue>();
for (int i = 0; i < 4; i++)
guid.Array.Add(new SaltPropertyReader.PropertyValue());
guidprop.Value = guid;
properties.Add("TFCFileGuid", guidprop);
}
properties.Add("None", none);
}
// copy specific properties from inTex
for (int i = 0; i < inTex.properties.Count; i++)
{
SaltPropertyReader.Property prop = inTex.properties.ElementAt(i).Value;
switch (prop.Name)
{
case "TextureFileCacheName":
arcName = prop.Value.StringValue;
properties["TextureFileCacheName"].Value.StringValue = arcName;
break;
case "TFCFileGuid":
SaltPropertyReader.Property GUIDProp = properties["TFCFileGuid"];
for (int l = 0; l < 4; l++)
{
SaltPropertyReader.PropertyValue tempVal = GUIDProp.Value.Array[l];
tempVal.IntValue = prop.Value.Array[l].IntValue;
GUIDProp.Value.Array[l] = tempVal;
}
break;
case "MipTailBaseIdx":
properties["MipTailBaseIdx"].Value.IntValue = prop.Value.IntValue;
break;
case "SizeX":
properties["SizeX"].Value.IntValue = prop.Value.IntValue;
break;
case "SizeY":
properties["SizeY"].Value.IntValue = prop.Value.IntValue;
break;
}
}
}
public void HardReplaceImage(string strImgSize, string fileToReplace)
{
if (!File.Exists(fileToReplace))
throw new FileNotFoundException("Required file was not found");
ImageFile dds = new DDS(fileToReplace, null);
if (strImgSize == null)
strImgSize = dds.imgSize.ToString();
if (privateimgList.Count != 1)
throw new Exception("Cannot use this function for a multi-level texture");
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
// Check for correct dimensions/ size
if (imgSize.width == privateimgList[0].imgSize.width)
{
if (imgSize.height != privateimgList[0].imgSize.height)
throw new FormatException("The input size is not the correct dimensions (Error: 0)");
}
else if (imgSize.width < privateimgList[0].imgSize.width)
{
if (privateimgList[0].imgSize.width / imgSize.width != privateimgList[0].imgSize.height / imgSize.height || (privateimgList[0].imgSize.width / imgSize.width) % 2 != 0)
throw new FormatException("The input size is not the correct size (Error: 1)");
}
else
{
if (imgSize.width / privateimgList[0].imgSize.width != imgSize.height / privateimgList[0].imgSize.height || (imgSize.width / privateimgList[0].imgSize.width) % 2 != 0)
throw new FormatException("The input size is not the correct size (Error: 2)");
}
if (dds.format == "R8G8B8")
{
byte[] buff = ImageMipMapHandler.ConvertTo32bit(dds.imgData, (int)dds.imgSize.width, (int)dds.imgSize.height);
dds = new DDS(null, dds.imgSize, "A8R8G8B8", buff);
}
if (Class == class2 || Class == class3)
ChangeFormat(dds.format);
if (texFormat == "PF_NormalMap_HQ")
{
if (dds.format != "ATI2")
throw new FormatException("Input texture is the wrong format");
}
else if (String.Compare(texFormat, "PF_" + dds.format, true) != 0 && String.Compare(texFormat, dds.format, true) != 0)
throw new FormatException("Input texture is the wrong format");
ImageInfo newImg = new ImageInfo();
newImg.storageType = privateimgList[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;
switch (newImg.storageType)
{
case storage.pccSto:
imageData = dds.resize();
newImg.cprSize = imageData.Length;
newImg.uncSize = imageData.Length;
break;
case storage.pccCpr:
SaltLZOHelper lzohelper = new SaltLZOHelper();
imageData = lzohelper.CompressTex(dds.resize());
newImg.cprSize = imageData.Length;
newImg.uncSize = dds.resize().Length;
break;
}
privateimgList.RemoveAt(0);
privateimgList.Add(newImg);
// Fix up properties
properties["SizeX"].Value.IntValue = (int)imgSize.width;
properties["SizeY"].Value.IntValue = (int)imgSize.height;
}