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