public void AddFile(string path, string entryPath, WADEntry entry)
{
char pathSeparator = Pathing.GetPathSeparator(path);
string[] folders = path.Split(pathSeparator);
//If folders length is 1 then we can add the file to this directory
//if not, then we pass it down the hierarchy
if (folders.Length == 1)
{
this.Items.Add(new WadFileViewModel(this._wadViewModel, this, entryPath, folders[0], entry));
}
else
{
//If the folder exists we pass the file to it
//if it doesn't then we create it before passing the file
if (this.Items.FirstOrDefault(x => x.Name == folders[0]) is WadFolderViewModel folder)
{
folder.AddFile(path.Substring(path.IndexOf(pathSeparator) + 1), entryPath, entry);
}
else
{
string newFolderPath = string.Format("{0}/{1}", this.Path, folders[0]);
WadFolderViewModel newFolder = new WadFolderViewModel(this._wadViewModel, this, newFolderPath);
newFolder.AddFile(path.Substring(path.IndexOf(pathSeparator) + 1), entryPath, entry);
this.Items.Add(newFolder);
}
}
}
public void applyMaterial(WADEntry entry, string path, GeometryModel3D model)
{
var stream = new MemoryStream(entry.GetContent(true));
ImageBrush colors_brush = new ImageBrush();
var imageSource = new BitmapImage();
imageSource.BeginInit();
imageSource.StreamSource = stream;
imageSource.EndInit();
colors_brush.ViewboxUnits = BrushMappingMode.RelativeToBoundingBox;
colors_brush.ViewportUnits = BrushMappingMode.Absolute;
colors_brush.AlignmentY = AlignmentY.Top;
colors_brush.AlignmentX = AlignmentX.Left;
colors_brush.TileMode = TileMode.Tile;
colors_brush.Stretch = Stretch.Fill;
colors_brush.ImageSource = imageSource;
DiffuseMaterial colors_material =
new DiffuseMaterial(colors_brush);
model.Material = colors_material;
if (!materialMap.ContainsKey(model))
{
materialMap.Add(model, path);
}
else
{
materialMap[model] = path;
}
_previewTextureComboBox.SelectedItem = path;
}
public static WADFile Merge(WADFile wadBase, WADFile wadMerge)
{
//First add new files and then modify changed ones
foreach (WADEntry entry in wadMerge.Entries)
{
WADEntry baseEntry = wadBase.Entries.FirstOrDefault(x => x.XXHash == entry.XXHash);
if (baseEntry == null)
{
if (entry.Type == EntryType.Uncompressed)
{
wadBase.AddEntry(entry.XXHash, entry.GetContent(false), false);
}
else if (entry.Type == EntryType.ZStandardCompressed || entry.Type == EntryType.Compressed)
{
wadBase.AddEntryCompressed(entry.XXHash, entry.GetContent(false), entry.UncompressedSize, entry.Type);
}
}
else if (!entry.SHA.SequenceEqual(baseEntry.SHA))
{
if (entry.Type == EntryType.Uncompressed)
{
wadBase.Entries.Single(x => x.XXHash == entry.XXHash).EditData(entry.GetContent(false));
}
else if (entry.Type == EntryType.ZStandardCompressed || entry.Type == EntryType.Compressed)
{
wadBase.Entries.Single(x => x.XXHash == entry.XXHash).EditData(entry.GetContent(false), entry.UncompressedSize);
}
}
}
return(wadBase);
}
public WadFileViewModel(WadViewModel wadViewModel, WadItemViewModel parent, string path, string name, WADEntry entry)
: base(wadViewModel, parent, WadItemType.File)
{
this.Path = path;
this.Name = name;
this.Entry = entry;
}
public TableNode(string name, string type, string size, string fileDirection, WADEntry entry)
{
this.name = name;
this.type = type;
this.size = size;
this.fileDirection = fileDirection;
this.entry = entry;
}
private static void ConvertScbToGltf(FileConversionParameter parameter)
{
WADEntry staticObjectWadEntry = parameter.Parameter;
using MemoryStream stream = new MemoryStream(staticObjectWadEntry.GetContent(true));
StaticObject staticObject = StaticObject.ReadSCB(stream);
ModelRoot gltf = staticObject.ToGltf();
gltf.SaveGLB(Path.ChangeExtension(parameter.OutputPath, "glb"));
}
private static void ConvertSimpleSkinToGltf(FileConversionParameter parameter)
{
WADEntry simpleSkinWadEntry = parameter.Parameter;
using MemoryStream stream = new MemoryStream(simpleSkinWadEntry.GetContent(true));
SimpleSkin simpleSkin = new SimpleSkin(stream);
ModelRoot gltf = simpleSkin.ToGltf();
gltf.SaveGLB(Path.ChangeExtension(parameter.OutputPath, "glb"));
}
private static void ConvertMapGeometryToGltf(FileConversionParameter parameter)
{
WADEntry mapGeometryWadEntry = parameter.Parameter;
using MemoryStream stream = new MemoryStream(mapGeometryWadEntry.GetContent(true));
MapGeometry mapGeometry = new MapGeometry(stream);
ModelRoot gltf = mapGeometry.ToGLTF();
gltf.SaveGLB(Path.ChangeExtension(parameter.OutputPath, "glb"));
}
private static IEnumerable <string> ProcessLegacyDirList(WADEntry entry)
{
using (BinaryReader br = new BinaryReader(new MemoryStream(entry.GetContent(true))))
{
uint pathCount = br.ReadUInt32();
for (int i = 0; i < pathCount; i++)
{
yield return(Encoding.ASCII.GetString(br.ReadBytes(br.ReadInt32())));
}
}
}
public static string Get(WADEntry entry)
{
if (_hashtable.ContainsKey(entry.XXHash))
{
return(_hashtable[entry.XXHash]);
}
else
{
string extension = LeagueUtilities.GetExtension(entry.GetContent(true));
return(string.Format("{0}.{1}", entry.XXHash.ToString("x16"), extension));
}
}
private static void ConvertSimpleSkinWithSkeletonToGltf(FileConversionParameter parameter)
{
WADEntry simpleSkinWadEntry = parameter.Parameter;
WADEntry skeletonWadEntry = parameter.AdditionalParameters.FirstOrDefault(x => x.Item1 == FileConversionAdditionalParameterType.Skeleton).Item2;
using MemoryStream simpleSkinStream = new MemoryStream(simpleSkinWadEntry.GetContent(true));
using MemoryStream skeletonStream = new MemoryStream(skeletonWadEntry.GetContent(true));
SimpleSkin simpleSkin = new SimpleSkin(simpleSkinStream);
Skeleton skeleton = new Skeleton(skeletonStream);
ModelRoot gltf = simpleSkin.ToGltf(skeleton);
gltf.SaveGLB(Path.ChangeExtension(parameter.OutputPath, "glb"));
}
static List <WADEntry> ProcessOnlineWAD(byte[] bytes)
{
MemoryStream stream = new MemoryStream(bytes);
BinaryReader reader = new BinaryReader(stream);
WADHeader header = new WADHeader();
header.magic = reader.ReadUInt32();
header.timestamp = reader.ReadUInt32();
header.numEntries = reader.ReadUInt32();
header.ffotdVersion = reader.ReadUInt32();
if (header.magic != 0x543377AB)
{
Console.WriteLine("Invalid or unsupported file.");
return(null);
}
Console.WriteLine("FFOTD version: {0}, entries: {1}",
header.ffotdVersion, header.numEntries);
List <WADEntry> entries = new List <WADEntry>();
for (int i = 0; i < header.numEntries; i++)
{
byte[] entryData = new byte[44]; //size of WADEntry
int index = (16 + (44 * i));
Array.Copy(bytes, index, entryData, 0, entryData.Length);
MemoryStream stream2 = new MemoryStream(entryData);
BinaryReader reader2 = new BinaryReader(stream2);
WADEntry entry = new WADEntry();
byte[] entryNameBytes = reader2.ReadBytes(32);
entry.name = Encoding.ASCII.GetString(entryNameBytes).Trim('\0');
entry.compressedSize = SwapUInt32(reader2.ReadUInt32());
entry.size = SwapUInt32(reader2.ReadUInt32());
entry.offset = SwapUInt32(reader2.ReadUInt32());
entry.compressedBuf = new byte[entry.compressedSize];
entries.Add(entry);
}
return(entries);
}
private static void ConvertScbToObj(FileConversionParameter parameter)
{
WADEntry staticObjectWadEntry = parameter.Parameter;
using MemoryStream stream = new MemoryStream(staticObjectWadEntry.GetContent(true));
StaticObject staticObject = StaticObject.ReadSCB(stream);
var objs = staticObject.ToObj();
string baseName = Path.GetFileNameWithoutExtension(parameter.OutputPath);
foreach ((string material, OBJFile obj) in objs)
{
string objPath = parameter.OutputPath.Replace(baseName, baseName + '_' + material);
obj.Write(objPath);
}
}
public async void AddFile(string fileLocation)
{
try
{
string entryName = PathIO.GetFileName(fileLocation).ToLower();
string entryPath = string.Format("{0}/{1}", this.Path, entryName);
ulong hash = XXHash.XXH64(Encoding.ASCII.GetBytes(entryPath.ToLower()));
WADEntry entry = new WADEntry(this._wadViewModel.WAD, hash, File.ReadAllBytes(fileLocation), true, PathIO.GetExtension(fileLocation));
this.Items.Add(new WadFileViewModel(this._wadViewModel, this, entryPath, entryName, entry));
}
catch (Exception exception)
{
await DialogHelper.ShowMessageDialog(string.Format("{0}\n{1}\n{2}", Localization.Get("WadFolderAddFileError"), fileLocation, exception));
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
WADEntry wadEntry = value as WADEntry;
string finalName;
if (MainWindow.StringDictionary.ContainsKey(wadEntry.XXHash))
{
finalName = MainWindow.StringDictionary[wadEntry.XXHash];
}
else
{
finalName = wadEntry.XXHash.ToString("X16");
}
return(finalName);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
WADEntry wadEntry = value as WADEntry;
/*string finalName;
*
* if (MainWindow.StringDictionary.ContainsKey(wadEntry.XXHash))
* {
* finalName = MainWindow.StringDictionary[wadEntry.XXHash];
* }
* else
* {
* finalName = wadEntry.XXHash.ToString("X16");
* }
*/
return(wadEntry.XXHash.ToString("X16"));
}
private static FileConversionParameter ConstructSimpleSkinWithSkeletonParameter(string outputPath, WadFileViewModel parameter, WadViewModel wad)
{
// We need to find a skeleton file with the same filename as the Simple Skin
string skeletonPath = Path.ChangeExtension(parameter.Path, "skl");
WADEntry skeletonWadEntry = wad.GetAllFiles().FirstOrDefault(x => x.Path == skeletonPath).Entry;
if (skeletonWadEntry is null)
{
throw new Exception(Localization.Get("ConversionSimpleSkinWithSkeletonSkeletonNotFound"));
}
else
{
return(new FileConversionParameter(outputPath, parameter.Entry, new List <(FileConversionAdditionalParameterType, WADEntry)>()
{
(FileConversionAdditionalParameterType.Skeleton, skeletonWadEntry)
}));
}
}
public void emit(WADEntry entry)
{
foreach (var nameEntry in MainWindow.StringDictionary)
{
if (nameEntry.Key == entry.XXHash)
{
if (extensionMatch(nameEntry.Value))
{
handle(entry, nameEntry.Value);
}
else if (_previewExpander.IsExpanded)
{
_previewExpander.IsExpanded = false;
}
break;
}
}
}
private void textBoxFilter_TextChanged(object sender, TextChangedEventArgs e)
{
this.datagridWadEntries.Items.Filter = objectEntry =>
{
WADEntry entry = (WADEntry)objectEntry;
string finalName;
if (StringDictionary.ContainsKey(entry.XXHash))
{
finalName = StringDictionary[entry.XXHash];
}
else
{
finalName = entry.XXHash.ToString("X16");
}
return(finalName.ToLower().Contains(this.textBoxFilter.Text.ToLower()));
};
}
public async void AddFolder(string folderLocation)
{
try
{
foreach (string fileLocation in Directory.EnumerateFiles(folderLocation, "*", SearchOption.AllDirectories))
{
char pathSeparator = Pathing.GetPathSeparator(fileLocation);
string path = fileLocation.Replace(PathIO.GetDirectoryName(folderLocation) + pathSeparator, "").Replace(pathSeparator, '/');
string entryPath = string.Format("{0}/{1}", this.Path, path);
ulong hash = XXHash.XXH64(Encoding.ASCII.GetBytes(entryPath.ToLower()));
WADEntry entry = new WADEntry(this._wadViewModel.WAD, hash, File.ReadAllBytes(fileLocation), true, PathIO.GetExtension(fileLocation));
AddFile(path, entryPath, entry);
}
}
catch (Exception exception)
{
await DialogHelper.ShowMessageDialog(string.Format("{0}\n{1}", Localization.Get("WadFolderAddFolderError"), exception));
}
}
static WAD WriteOnlineWAD(string[] filenames)
{
WADHeader header = new WADHeader();
header.magic = 0x543377AB;
header.timestamp = 13371337;
header.numEntries = (uint)filenames.Length;
header.ffotdVersion = 0;
List <WADEntry> entries = new List <WADEntry>();
uint offset = 16 + (header.numEntries * 44);
foreach (string name in filenames)
{
string[] nameA = name.Split('\\');
string name2 = nameA[nameA.Length - 1];
Console.WriteLine("Compressing " + name2 + "...");
WADEntry entry = new WADEntry();
byte[] decompressedBuf = File.ReadAllBytes(name);
byte[] compressedBuf = ZlibStream.CompressBuffer(decompressedBuf);
entry.name = name2;
entry.compressedBuf = compressedBuf;
entry.compressedSize = (uint)compressedBuf.Length;
entry.offset = offset;
entry.size = (uint)decompressedBuf.Length;
offset += entry.compressedSize;
entries.Add(entry);
}
WAD wad = new WAD();
wad.header = header;
wad.entries = entries;
return(wad);
}
private void handle(WADEntry entry, string namePath)
{
if (namePath.ToLower().EndsWith(".dds"))
{
if (mode == 0)
{
mode = 1;
_viewPort.Visibility = Visibility.Collapsed;
_previewImage.Visibility = Visibility.Visible;
_previewTextureComboBox.IsEnabled = false;
_previewMeshesComboBox.IsEnabled = false;
}
_previewTypeLabel.Content = "Type: DirectDraw Surface";
_previewNameLabel.Content = "Name: " + namePath.Split('/').Last();
var stream = new MemoryStream();
var image = DDS.LoadImage(entry.GetContent(true));
image.Save(stream, ImageFormat.Png);
var imageSource = new BitmapImage();
imageSource.CacheOption = BitmapCacheOption.OnLoad;
imageSource.BeginInit();
imageSource.StreamSource = stream;
imageSource.EndInit();
imageSource.Freeze();
_previewImage.Dispatcher.BeginInvoke(new Action(() =>
{
_previewImage.Source = imageSource;
_previewImage.Width = image.Width;
_previewImage.Height = image.Height;
}));
return;
}
if (mode == 1)
{
mode = 0;
_previewImage.Visibility = Visibility.Collapsed;
_viewPort.Visibility = Visibility.Visible;
}
clearUp();
_previewTextureComboBox.IsEnabled = true;
_previewMeshesComboBox.IsEnabled = true;
if (!_previewExpander.IsExpanded)
{
_previewExpander.IsExpanded = true;
}
if (namePath.ToLower().EndsWith(".scb"))
{
_previewMeshesComboBox.IsEnabled = false;
var model = applyMesh(new SCBFile(new MemoryStream(entry.GetContent(true))));
_previewTypeLabel.Content = "Type: Static Object Binary";
_previewNameLabel.Content = "Name: " + namePath.Split('/').Last();
if (PreSelect != null)
{
foreach (var wadEntry in window.Wad.Entries)
{
if (wadEntry.XXHash == PreSelect.Item2)
{
applyMaterial(wadEntry, PreSelect.Item1, model);
break;
}
}
PreSelect = null;
}
else
{
applyMaterial(model);
}
return;
}
if (namePath.ToLower().EndsWith(".sco"))
{
_previewMeshesComboBox.IsEnabled = false;
var model = applyMesh(new SCOFile(new MemoryStream(entry.GetContent(true))));
_previewTypeLabel.Content = "Type: Static Object Mesh";
_previewNameLabel.Content = "Name: " + namePath.Split('/').Last();
if (PreSelect != null)
{
foreach (var wadEntry in window.Wad.Entries)
{
if (wadEntry.XXHash == PreSelect.Item2)
{
applyMaterial(wadEntry, PreSelect.Item1, model);
break;
}
}
PreSelect = null;
}
else
{
applyMaterial(model);
}
return;
}
var result = generateInfoHolder(namePath);
if (result == null)
{
return;
}
var skn = new SKNFile(new MemoryStream(result.sknPath.GetContent(true)));
foreach (var subMesh in skn.Submeshes)
{
var model = applyMesh(subMesh);
_previewNameLabel.Content = "Name: " + namePath.Split('/').Last();
_previewTypeLabel.Content = "Type: Simple Skin Mesh";
if (PreSelect != null)
{
foreach (var wadEntry in window.Wad.Entries)
{
if (wadEntry.XXHash == PreSelect.Item2)
{
applyMaterial(wadEntry, PreSelect.Item1, model);
break;
}
}
}
else
{
if (result.textures.Count > 0)
{
applyMaterial(result.textures.First().Value, result.textures.First().Key, model);
}
else
{
applyMaterial(model);
}
}
}
PreSelect = null;
}
public InfoHolder(WADEntry sknPath, WADEntry sklPath, Dictionary <string, WADEntry> textures)
{
this.sknPath = sknPath;
this.sklPath = sklPath;
this.textures = textures;
}