public static Stream OpenFile(string filename) { if (usingLocalAPI) { var response = Client.GetAsync("http://" + CASCToolHostURL + "/casc/file/fname?buildconfig=" + BuildConfig + "&cdnconfig=" + CDNConfig + "&filename=" + filename); return(response.Result.Content.ReadAsStreamAsync().Result); } else { return(cascHandler.OpenFile(filename)); } }
public static Stream GetFile(string from) { try { return(_casc.OpenFile(from)); } catch { if (!from.Contains(".adt")) { Console.WriteLine("Problem: " + from); } return(null); } }
public static void Load_hTextures(CASCHandler Handler) { if (ADTTexData.textureBlockData.MTXP) { ADTTexData.textureBlockData.terrainHTextures = new Dictionary <uint, ADTTexData.Texture2Ddata>(); foreach (uint TextureFileDataId in ADTTexData.textureBlockData.terrainTextureFileDataIds) { using (var stream = Handler.OpenFile(TextureFileDataId)) { BLP blp = new BLP(); byte[] data = blp.GetUncompressed(stream, true); BLPinfo info = blp.Info(); ADTTexData.Texture2Ddata texture2Ddata = new ADTTexData.Texture2Ddata(); texture2Ddata.hasMipmaps = info.hasMipmaps; texture2Ddata.width = info.width; texture2Ddata.height = info.height; if (info.width != info.height) // Unity doesn't support nonsquare mipmaps // sigh { texture2Ddata.hasMipmaps = false; } texture2Ddata.textureFormat = info.textureFormat; texture2Ddata.TextureData = data; ADTTexData.textureBlockData.terrainHTextures.Add(TextureFileDataId, texture2Ddata); stream.Close(); } } } }
public bool LoadFile(CASCHandler cascHandler, uint fileDataId, string description) { var file = cascHandler.OpenFile((int)fileDataId); if (file == null) { return(false); } var fileSize = file.Length; if (fileSize == 0xFFFFFFFF) { return(false); } dataSize = (uint)fileSize; data = new BinaryReader(file).ReadBytes((int)dataSize); ParseChunks(); if (PrepareLoadedData()) { return(true); } Console.WriteLine($"Error loading {description}\n"); return(false); }
public Stream OpenFile(ApplicationPackageManifest.Types.PackageRecord record) { long offset = 0; EncodingEntry enc; if (record.Flags.HasFlag(ContentFlags.Bundle)) { offset = record.Offset; } if (!CASC.EncodingHandler.GetEntry(record.LoadHash, out enc)) { return(null); } MemoryStream ms = new MemoryStream((int)record.Size); try { Stream fstream = CASC.OpenFile(enc.Key); fstream.Position = offset; fstream.CopyBytes(ms, (int)record.Size); ms.Position = 0; } catch (Exception e) { if (e is BLTEKeyException exception) { Debugger.Log(0, "DataTool", $"[DataTool:CASC]: Missing key: {exception.MissingKey:X16}\r\n"); } return(null); } return(ms); }
public static void ReadTXID(BinaryReader br, M2Data m2Data, CASCHandler CascHandler, uint Size) { LoadedBLPFileDataIds.Clear(); var numTextures = Size / 4; for (int i = 0; i < numTextures; i++) { uint texture = br.ReadUInt32(); M2Texture m2Texture = new M2Texture(); Texture2Ddata texture2Ddata = new Texture2Ddata(); if (!LoadedBLPFileDataIds.Contains(texture)) { var stream = CascHandler.OpenFile(texture); BLP blp = new BLP(); byte[] data = blp.GetUncompressed(stream, true); BLPinfo info = blp.Info(); texture2Ddata.hasMipmaps = info.hasMipmaps; texture2Ddata.width = info.width; texture2Ddata.height = info.height; texture2Ddata.textureFormat = info.textureFormat; texture2Ddata.TextureData = data; m2Texture.texture2Ddata = texture2Ddata; m2Texture.FileDataId = texture; stream.Close(); stream.Dispose(); LoadedBLPFileDataIds.Add(texture); } m2Data.m2Tex.Add(m2Texture); } }
public static Stream OpenFile(uint fileDataId) { if (!Directory.Exists("Cache")) { Directory.CreateDirectory("Cache"); } if (File.Exists($"Cache/{fileDataId}")) { var stream = File.Open($"Cache/{fileDataId}", FileMode.Open, FileAccess.Read, FileShare.Read); return(stream); } else if (cascHandler.FileExists((int)fileDataId)) { var stream = cascHandler.OpenFile((int)fileDataId); var buffer = new byte[stream.Length]; // Read the data and save the file. stream.Read(buffer, 0, buffer.Length); File.WriteAllBytes($"Cache/{fileDataId}", buffer); stream.Position = 0; return(stream); } return(null); }
/// <summary> /// Read the WDT file. /// </summary> public void ReadWDT(CASCHandler handler, uint wdtfiledataid) { var stream = handler.OpenFile((int)wdtfiledataid); if (stream == null) { return; } using (var reader = new BinaryReader(stream)) { while (reader.BaseStream.Position < reader.BaseStream.Length) { var chunkId = (Chunk)reader.ReadUInt32(); var chunkSize = reader.ReadUInt32(); switch (chunkId) { case Chunk.MAID: for (var x = 0; x < 64; ++x) { for (var y = 0; y < 64; ++y) { var rootAdt = reader.ReadUInt32(); var obj0Adt = reader.ReadUInt32(); var obj1Adt = reader.ReadUInt32(); var tex0Adt = reader.ReadUInt32(); var lodAdt = reader.ReadUInt32(); var mapTexture = reader.ReadUInt32(); var mapTextureN = reader.ReadUInt32(); var minimapTexture = reader.ReadUInt32(); if (rootAdt == 0) { continue; } MAIDs.Add($"{y}_{x}", new MAID { RootADT = rootAdt, Obj0ADT = obj0Adt, Obj1ADT = obj1Adt, Tex0ADT = tex0Adt, LodADT = lodAdt, MapTexture = mapTexture, MapTextureN = mapTextureN, MinimapTexture = minimapTexture, }); } } break; default: Skip(reader, chunkSize); break; } } } }
public bool loadFile(CASCHandler cascHandler, string fileName) { var file = cascHandler.OpenFile(fileName); if (file == null) { return(false); } var fileSize = file.Length; if (fileSize == 0xFFFFFFFF) { return(false); } data_size = (uint)fileSize; _data = new BinaryReader(file).ReadBytes((int)data_size); parseChunks(); if (prepareLoadedData()) { return(true); } Console.WriteLine($"Error loading {fileName}\n"); return(false); }
public static Stream OpenFile(Record record, CASCHandler handler) { long offset = 0; EncodingEntry enc; if (((ContentFlags)record.record.Flags & ContentFlags.Bundle) == ContentFlags.Bundle) { offset = record.record.Offset; handler.Encoding.GetEntry(record.index.bundleContentKey, out enc); } else { handler.Encoding.GetEntry(record.record.ContentKey, out enc); } MemoryStream ms = new MemoryStream(record.record.Size); try { Stream fstream = handler.OpenFile(enc.Key); fstream.Position = offset; CopyBytes(fstream, ms, record.record.Size); ms.Position = 0; } catch (Exception ex) { Console.Out.WriteLine("Error {0} with file {2:X12}.{3:X3} ({1})", ex.Message, TypeAlias(GUID.Type(record.record.Key)), GUID.LongKey(record.record.Key), GUID.Type(record.record.Key)); return(null); } if (System.Diagnostics.Debugger.IsAttached) { System.Diagnostics.Debugger.Log(0, "CASC:IO", $"[CASC:IO] Opened file {GUID.LongKey(record.record.Key):X12}.{GUID.Type(record.record.Key):X3}\n"); } return(ms); }
private static void ParseM2_Skin(uint skinFileId, M2Data m2Data, CASCHandler CascHandler) { var stream = CascHandler.OpenFile(skinFileId); using (BinaryReader reader = new BinaryReader(stream)) { ParseSkin(reader, m2Data); } }
public static bool ParseWDT(uint FileDataId) { long streamPos = 0; CASC = GameObject.Find("[CASC]").GetComponent <CascHandler>().cascHandler; if (CASC.FileExists(FileDataId)) { using (var stream = CASC.OpenFile(FileDataId)) using (var reader = new BinaryReader(stream)) { WDTflagsdata WDTFlags = new WDTflagsdata(); while (streamPos < stream.Length) { stream.Position = streamPos; WDTChunkId ChunkId = (WDTChunkId)reader.ReadUInt32(); uint ChunkSize = reader.ReadUInt32(); streamPos = stream.Position + ChunkSize; switch (ChunkId) { case WDTChunkId.MVER: ReadMVER(reader); break; case WDTChunkId.MPHD: ReadMPHD(reader, WDTFlags); break; case WDTChunkId.MAIN: ReadMAIN(reader, WDTFlags); break; case WDTChunkId.MAID: ReadMAID(reader, FileDataId); break; default: SkipUnknownChunk(stream, ChunkId, ChunkSize); break; } } if (!Flags.ContainsKey(FileDataId)) { Flags.Add(FileDataId, WDTFlags); } } return(true); } else { return(false); } }
public static Stream OpenFile(MD5Hash hash, CASCHandler handler) { try { Stream fstream = handler.OpenFile(hash); return(fstream); } catch (Exception ex) { Console.Out.WriteLine("Error {0}", ex.Message); return(null); } }
// materials // public static void ReadMOMT(BinaryReader reader, int MOMTsize, CASCHandler Handler) { wmoData.Info.nMaterials = MOMTsize / 64; for (int i = 0; i < wmoData.Info.nMaterials; i++) { WMOMaterial material = new WMOMaterial(); material.flags = reader.ReadMaterialFlags(); material.ShaderType = (WMOFragmentShader)reader.ReadUInt32(); // Index into CMapObj::s_wmoShaderMetaData. See below (shader types). material.BlendMode = (BlendingMode)reader.ReadUInt32(); // Blending: see https://wowdev.wiki/Rendering#EGxBlend material.TextureId1 = reader.ReadUInt32(); // offset into MOTX; ≥ Battle (8.1.0.27826) No longer references MOTX but is a filedata id directly. material.SidnColor = reader.ReadBGRA(); // emissive color; see below (emissive color) material.FrameSidnColor = reader.ReadBGRA(); // sidn emissive color; set at runtime; gets sidn-manipulated emissive color; see below (emissive color) material.TextureId2 = reader.ReadUInt32(); // Environment Texture; envNameIndex; offset into MOTX material.DiffColor = reader.ReadBGRA(); // diffuse color; CWorldView::GatherMapObjDefGroupLiquids(): geomFactory->SetDiffuseColor((CImVectorⁱ*)(smo+7)); // environment textures don't need flags material.GroundType = reader.ReadUInt32(); // foreign_keyⁱ< uint32_t, &TerrainTypeRec::m_ID > ground_type; // according to CMapObjDef::GetGroundType material.TextureId3 = reader.ReadUInt32(); // offset into MOTX material.Color = reader.ReadBGRA(); material.texture3_flags = reader.ReadMaterialFlags(); // skip runtime data // reader.BaseStream.Seek(16, SeekOrigin.Current); wmoData.materials.Add(material); if (!wmoData.texturePaths.ContainsKey(material.TextureId1)) { wmoData.texturePaths.Add(material.TextureId1, material.TextureId1); } if (material.TextureId1 != 0) { Texture2Ddata textureData = new Texture2Ddata(); Stream stream = Handler.OpenFile(material.TextureId1); BLP blp = new BLP(); byte[] data = blp.GetUncompressed(stream, true); BLPinfo info = blp.Info(); textureData.hasMipmaps = info.hasMipmaps; textureData.width = info.width; textureData.height = info.height; textureData.textureFormat = info.textureFormat; textureData.TextureData = data; stream.Close(); stream.Dispose(); LoadedBLPs.Add(material.TextureId1); if (!wmoData.textureData.ContainsKey(material.TextureId1)) { wmoData.textureData.Add(material.TextureId1, textureData); } } } } // loaded
public static Stream OpenFile(uint fileDataId) { if (!cascHandler.FileExists((int)fileDataId)) { return(null); } var stream = cascHandler.OpenFile((int)fileDataId); return(stream); }
public static Stream GetFile(string from) { try { return(CASC.OpenFile(from, LocaleFlags.All)); } catch { Console.WriteLine("Problem: " + from); return(null); } }
public static Stream OpenFile(CASCHandler casc, MD5Hash hash) { try { return(casc.EncodingHandler.GetEntry(hash, out EncodingEntry enc) ? casc.OpenFile(enc.Key) : null); } catch (Exception e) { if (e is BLTEKeyException exception) { Debugger.Log(0, "TankLibTest:CASC", $"Missing key: {exception.MissingKey:X16}\r\n"); } return(null); } }
public static IEnumerable <KeyValuePair <int, WDC3Row> > EnumerateTable(this CASCFolder folder, string name, CASCHandler handler) { var entry = folder.GetEntry(name + ".db2"); using var stream = handler.OpenFile(entry.Hash); var reader = new WDC3Reader(stream); foreach (var pair in reader) { yield return(pair); } }
// Terrain Texture Parser // private static void ParseADT_Tex(uint TexFileDataId, CASCHandler Handler, uint WdtFileDataId) { ADTTex t = new ADTTex(); int MCNKchunkNumber = 0; long StreamPos = 0; using (var stream = Handler.OpenFile(TexFileDataId)) using (var reader = new BinaryReader(stream)) { while (StreamPos < stream.Length) { stream.Position = StreamPos; ADTChunkId chunkID = (ADTChunkId)reader.ReadInt32(); uint chunkSize = reader.ReadUInt32(); StreamPos = stream.Position + chunkSize; switch (chunkID) { case ADTChunkId.MVER: t.ReadMVER(reader); // ADT file version break; case ADTChunkId.MAMP: t.ReadMAMP(reader); // Single value - texture size = 64 break; case ADTChunkId.MCNK: { t.ReadMCNKtex(reader, WdtFileDataId, MCNKchunkNumber, chunkSize); // Texture Data - 256chunks MCNKchunkNumber++; } break; case ADTChunkId.MTXP: t.ReadMTXP(reader, chunkSize); break; case ADTChunkId.MHID: t.ReadMHID(reader, chunkSize, Handler); break; case ADTChunkId.MDID: t.ReadMDID(reader, chunkSize, Handler); break; default: SkipUnknownChunk(stream, chunkID, chunkSize); break; } } } }
public static void CompareEnc(string[] args) { string otherVerNum = args[2]; HashSet <ulong> missingKeys = new HashSet <ulong>(); Directory.CreateDirectory(RawEncDir); Directory.CreateDirectory(ConvertEncDir); string[] otherHashes; using (StreamReader reader = new StreamReader($"{otherVerNum}.enchashes")) { otherHashes = reader.ReadToEnd().Split('\n').Select(x => x.TrimEnd('\r')).Where(x => !string.IsNullOrWhiteSpace(x)).ToArray(); } Dictionary <MD5Hash, int> otherHashDict = new Dictionary <MD5Hash, int>(new MD5HashComparer()); foreach (MD5Hash hash in otherHashes.Select(x => x.ToByteArray().ToMD5())) { otherHashDict[hash] = 0; } foreach (KeyValuePair <MD5Hash, EncodingEntry> entry in CASC.EncodingHandler.Entries) { string md5 = entry.Key.ToHexString(); if (!otherHashDict.ContainsKey(entry.Key)) { try { Stream stream = CASC.OpenFile(entry.Value.Key); TryConvertFile(stream, ConvertEncDir, md5); //stream.Position = 0; //using (Stream file = File.OpenWrite(Path.Combine(RawEncDir, md5))) { // stream.CopyTo(file); //} } catch (Exception e) { if (e is BLTEKeyException exception) { if (missingKeys.Add(exception.MissingKey)) { Console.Out.WriteLine($"Missing key: {exception.MissingKey:X16}"); } } else { Console.Out.WriteLine(e); } } } } }
protected Stream OpenFile(string filePath) { if (StorageMode == StorageMode.CASC) { return(CASCHandler.OpenFile(filePath)); } else if (StorageMode == StorageMode.Mods) { return(File.Open(Path.Combine(ModsFolderPath, filePath.Substring(5)), FileMode.Open)); } else { return(null); } }
// Terrain Mesh Parser // private static void ParseADT_Main(uint RootAdtFileDataId, CASCHandler Handler) // MS version { ADTRoot r = new ADTRoot(); int MCNKchunkNumber = 0; long StreamPos = 0; using (var stream = Handler.OpenFile(RootAdtFileDataId)) using (var reader = new BinaryReader(stream)) { while (StreamPos < stream.Length) { stream.Position = StreamPos; ADTChunkId chunkID = (ADTChunkId)reader.ReadInt32(); uint chunkSize = reader.ReadUInt32(); StreamPos = stream.Position + chunkSize; switch (chunkID) { case ADTChunkId.MVER: r.ReadMVER(reader); // ADT file version break; case ADTChunkId.MHDR: r.ReadMHDR(reader); // Offsets for specific chunks 0000 if chunks don't exist. break; // case ADTChunkId.MH2O: // r.ReadMH2O(reader, chunkSize); // Water Data // break; case ADTChunkId.MCNK: { r.ReadMCNK(reader, MCNKchunkNumber, chunkSize); // Terrain Data - 256chunks MCNKchunkNumber++; } break; case ADTChunkId.MFBO: r.ReadMFBO(reader); // FlightBounds plane & Death plane break; default: SkipUnknownChunk(stream, chunkID, chunkSize); break; } } } }
/// <summary> /// Open a new <see cref="BinaryReader"/> instance with the given FileId. /// </summary> public static BinaryReader OpenFile(uint fileDataId) { if (!NewStorage.FileExists((int)fileDataId)) { return(null); } var stream = NewStorage.OpenFile((int)fileDataId); if (stream == null) { return(null); } return(new BinaryReader(stream)); }
// Terrain Models Parser // public static void ParseADT_Obj(uint OBJFileDataId, CASCHandler Handler) { ADTObj o = new ADTObj(); int MCNKchunkNumber = 0; long StreamPos = 0; using (var stream = Handler.OpenFile(OBJFileDataId)) using (BinaryReader reader = new BinaryReader(stream)) { while (stream.Position < stream.Length) { stream.Position = StreamPos; ADTChunkId chunkID = (ADTChunkId)reader.ReadInt32(); uint chunkSize = reader.ReadUInt32(); StreamPos = stream.Position + chunkSize; switch (chunkID) { case ADTChunkId.MVER: o.ReadMVER(reader); // ADT file version break; case ADTChunkId.MDDF: o.ReadMDDF(reader, chunkSize); // Placement information for doodads (M2 models). break; case ADTChunkId.MODF: o.ReadMODF(reader, chunkSize); // Placement information for WMOs. break; case ADTChunkId.MCNK: { o.ReadMCNKObj(reader, MCNKchunkNumber, chunkSize); // 256chunks MCNKchunkNumber++; } break; default: SkipUnknownChunk(stream, chunkID, chunkSize); break; } } } }
public DB2Reader(uint FileDataId) { Casc = GameObject.Find("[CASC]").GetComponent <CascHandler>().cascHandler; var stream = Casc.OpenFile(FileDataId); using (var bin = new BinaryReader(stream)) { var identifier = new string(bin.ReadChars(4)); stream.Position = 0; switch (identifier) { case "WDC3": _reader = new WDC3(stream); break; default: Debug.Log("DBC Type " + identifier + " is not supported"); break; } } }
public static Stream OpenFile(PackageRecord record, CASCHandler handler) { long offset = 0; EncodingEntry enc; if (record.Flags.HasFlag(ContentFlags.Bundle)) { offset = record.Offset; } if (!handler.Encoding.GetEntry(record.Hash, out enc)) { return(null); } MemoryStream ms = new MemoryStream((int)record.Size); try { Stream fstream = handler.OpenFile(enc.Key); fstream.Position = offset; CopyBytes(fstream, ms, (int)record.Size); ms.Position = 0; } catch (Exception ex) { Console.Out.WriteLine("Error {0} with file {2} ({1})", ex.Message, TypeAlias(GUID.Type(record.GUID)), GUID.AsString(record.GUID)); return(null); } if (System.Diagnostics.Debugger.IsAttached) { System.Diagnostics.Debugger.Log(0, "CASC:IO", $"[CASC:IO] Opened file {GUID.AsString(record.GUID)}\n"); } return(ms); }
private static void ParseM2_Root(uint fileDataID, M2Data m2Data, M2Texture m2Tex, CASCHandler CascHandler) { long streamPos = 0; using (var stream = CascHandler.OpenFile(fileDataID)) using (BinaryReader reader = new BinaryReader(stream)) { while (streamPos < stream.Length) { stream.Position = streamPos; M2ChunkId chunkID = (M2ChunkId)reader.ReadUInt32(); uint chunkSize = reader.ReadUInt32(); streamPos = stream.Position + chunkSize; switch (chunkID) { case M2ChunkId.MD21: ReadMD21(reader, m2Data, m2Tex); break; case M2ChunkId.SFID: ReadSFID(reader, chunkSize); break; case M2ChunkId.TXID: ReadTXID(reader, m2Data, CascHandler, chunkSize); break; default: SkipUnknownChunk(stream, chunkSize); break; } } }; }
protected override void LoadCoreStormMod() { SetCorrectFileCasing(); if (LoadXmlFilesEnabled) { // core.stormmod xml files CASCFolder currentFolder = CASCFolderData.GetDirectory(Path.Combine(CoreBaseDataDirectoryPath, GameDataStringName)); foreach (KeyValuePair <string, ICASCEntry> file in currentFolder.Entries) { if (Path.GetExtension(file.Key) != ".xml") { continue; } string filePath = ((CASCFile)file.Value).FullName; if (!CASCHandlerData.FileExists(filePath)) { throw new FileNotFoundException(filePath); } using (Stream stream = CASCHandlerData.OpenFile(filePath)) { if (XmlGameData.LastNode == null) { XmlGameData = XDocument.Load(stream); XmlFileCount++; if (IsCacheEnabled) { AddXmlCachedFilePath(filePath); } } else { LoadXmlFile(stream, filePath); } } } } if (LoadTextFilesOnlyEnabled) { string filePath = Path.Combine(CoreLocalizedDataPath, GameStringFile); LoadTextFile(CASCHandlerData.OpenFile(filePath), filePath); } string fontStylesFilePath = Path.Combine(CoreBaseDataDirectoryPath, UIDirectoryStringName, FontStyleFile); LoadStormStyleFile(CASCHandlerData.OpenFile(fontStylesFilePath)); if (IsCacheEnabled) { AddStormStyleCachedFilePath(fontStylesFilePath); } }
public static Stream ReadThisFile(string filename) { Stream stream = null; if (usingCasc) //CASC { stream = cascHandler.OpenFile(filename); } else //MPQ { //Find the goddamn file in the archive hell int index = MainListFile.FindIndex(a => a.Contains(filename.ToLower())); if (index != -1) { //Get the archive in which the requested file resides string archive = MainListFile[index]; archive = archive.Substring(archive.LastIndexOf(';', archive.Length - 2) + 1); switch (archive.Substring(0, archive.Length - 4).Replace("-", "")) { //Mysts case "expansion4": stream = expansion4.OpenFile(filename); break; case "model": stream = model.OpenFile(filename); break; //Cataclysm case "art": stream = art.OpenFile(filename); break; case "expansion1": stream = expansion1.OpenFile(filename); break; case "expansion2": stream = expansion2.OpenFile(filename); break; case "expansion3": stream = expansion3.OpenFile(filename); break; case "world": stream = world.OpenFile(filename); break; case "world2": stream = world2.OpenFile(filename); break; case "locale1": stream = locale1.OpenFile(filename); break; //Lich King case "common": stream = common.OpenFile(filename); break; case "common2": stream = common2.OpenFile(filename); break; case "expansion": stream = expansion.OpenFile(filename); break; case "lichking": stream = lichking.OpenFile(filename); break; case "patch": stream = patch.OpenFile(filename); break; case "patch2": stream = patch2.OpenFile(filename); break; case "patch3": stream = patch3.OpenFile(filename); break; //Vanilla case "base": stream = baseMPQ.OpenFile(filename); break; case "dbc": stream = dbc.OpenFile(filename); break; case "interface": stream = interfaceMPQ.OpenFile(filename); break; case "misc": stream = misc.OpenFile(filename); break; case "sound": stream = sound.OpenFile(filename); break; case "terrain": stream = terrain.OpenFile(filename); break; case "texture": stream = texture.OpenFile(filename); break; case "wmo": stream = wmo.OpenFile(filename); break; } } else { //Missing file stream = null; } } return(stream); }
public static Stream OpenFile(string filename) { return(cascHandler.OpenFile(filename)); }