public override void Read(BlamLib.IO.EndianReader s) { CacheFile cache = s.Owner as CacheFile; bool isPC = cache.EngineVersion.IsPc() || cache.EngineVersion == BlamVersion.Halo1_XboxX; #region base address Managers.BlamDefinition bdef = Program.GetManager(cache.EngineVersion); cache.AddressMask = bdef[cache.EngineVersion].CacheTypes.BaseAddress - (uint)cache.Header.OffsetToIndex; #endregion address = s.ReadUInt32(); scenario.Read(s); s.ReadInt32(); // CRC tagCount = s.ReadInt32(); vertexBufferCount = s.ReadInt32(); vertexBufferAddress = s.ReadUInt32(); vertexBufferOffset = (int)(vertexBufferAddress - cache.AddressMask); indexBufferCount = s.ReadInt32(); indexBufferAddress = s.ReadUInt32(); indexBufferOffset = (int)(indexBufferAddress - cache.AddressMask); if (isPC) { s.ReadInt32(); // total vertex and index buffer size } s.ReadInt32(); // 'tags' tagsOffset = s.PositionUnsigned; ReadTagInstances(s, cache); InitializeBspTags(s, cache); }
protected void ReadGroupTags(Managers.BlamDefinition gd, IO.EndianReader s) { uint gt = s.ReadUInt32(); if (gt != uint.MaxValue) { GroupTag1 = gd.TagGroupFind(TagInterface.TagGroup.FromUInt(gt)); } else { GroupTag1 = TagInterface.TagGroup.Null; } gt = s.ReadUInt32(); if (gt != uint.MaxValue) { GroupTag2 = gd.TagGroupFind(TagInterface.TagGroup.FromUInt(gt)); } else { GroupTag2 = TagInterface.TagGroup.Null; } gt = s.ReadUInt32(); if (gt != uint.MaxValue) { GroupTag3 = gd.TagGroupFind(TagInterface.TagGroup.FromUInt(gt)); } else { GroupTag3 = TagInterface.TagGroup.Null; } }
public void Dispose() { compiler.Dispose(); if (scriptingInterface != null) { scriptingInterface = null; Managers.BlamDefinition gd = Program.GetManager(this.engine); (gd as Managers.IScriptingController).ScriptingCacheClose(this.engine); } }
protected ProjectState(BlamVersion engine, Project proj) { this.engine = engine; Managers.GameManager.Namespace nspace; Managers.GameManager.Platform plat; // Get the namespace of the engine we're using Managers.GameManager.FromBlamVersion(engine, out nspace, out plat); // Read the CheApe engine definition data we need for importing definition = new XmlInterface(engine); definition.Read(Managers.GameManager.GetRelativePath(nspace), "CheApe.xml"); InitializeTypeIndicies(); proj.OwnerState = this; project = proj; Managers.BlamDefinition gd = Program.GetManager(engine); (gd as Managers.IScriptingController).ScriptingCacheOpen(engine); scriptingInterface = gd[engine].GetResource <Scripting.XmlInterface>(Managers.BlamDefinition.ResourceScripts); }
void ReadBeta(BlamLib.IO.EndianReader s) { s.ReadUInt32(); //s.ReadBool(); //s.ReadBool(); // false if it belongs to a untracked build //s.ReadBool(); //s.ReadBool(); // Just read the booleans as a f*****g int... s.ReadInt32(); // Filetime.dwHighDateTime = s.ReadInt32(); // Filetime.dwLowDateTime = s.ReadInt32(); s.ReadInt32(); s.ReadInt32(); s.ReadInt32(); s.ReadInt32(); s.ReadInt32(); #region string id // retail doesn't include the 128 byte per string id table, so nix the members /*stringIdsBufferAlignedOffset = */ s.ReadInt32(); stringIdsCount = s.ReadInt32(); stringIdsBufferSize = s.ReadInt32(); stringIdIndicesOffset = s.ReadInt32(); stringIdsBufferOffset = s.ReadInt32(); #endregion #region filetimes? // pretty sure this is a flags field // used to tell which of the following 64bit values // are used. Damn sure this are FILETIME structures, but // hex workshop doesn't like them so I can't be for sure... s.ReadInt32(); Filetime.dwHighDateTime = s.ReadInt32(); Filetime.dwLowDateTime = s.ReadInt32(); if (s.ReadInt32() != 0) { flags.Add(CacheHeaderFlags.DependsOnMainMenu); } s.ReadInt32(); if (s.ReadInt32() != 0) { flags.Add(CacheHeaderFlags.DependsOnShared); } s.ReadInt32(); if (s.ReadInt32() != 0) { flags.Add(CacheHeaderFlags.DependsOnCampaign); } s.ReadInt32(); #endregion name = s.ReadTagString(); s.ReadInt32(); scenarioPath = s.ReadAsciiString(256); needsShared = s.ReadInt32() == 1; #region tag names tagNamesCount = s.ReadInt32(); tagNamesBufferOffset = s.ReadInt32(); tagNamesBufferSize = s.ReadInt32(); tagNameIndicesOffset = s.ReadInt32(); #endregion checksum = s.ReadUInt32(); // 0x2CC s.Seek(32, System.IO.SeekOrigin.Current); // these bytes are always the same baseAddress = s.ReadUInt32(); // expected base address xdkVersion = s.ReadInt32(); // xdk version #region memory partitions memoryPartitions = new Partition[3]; memoryPartitions[0].BaseAddress = s.ReadUInt32(); // address memoryPartitions[0].Size = s.ReadInt32(); // size memoryPartitions[1].BaseAddress = s.ReadUInt32(); // address memoryPartitions[1].Size = s.ReadInt32(); // size memoryPartitions[2].BaseAddress = s.ReadUInt32(); // address memoryPartitions[2].Size = s.ReadInt32(); // size #endregion s.Seek(256, System.IO.SeekOrigin.Current); s.Seek(1004 + sizeof(uint), System.IO.SeekOrigin.Current); Managers.BlamDefinition bdef = Program.GetManager(BlamVersion.Halo3_Beta); uint base_address = (s.Owner as Blam.CacheFile).AddressMask = bdef[BlamVersion.Halo3_Beta].CacheTypes.BaseAddress - (uint)MemoryBufferOffset; offsetToIndex = (int)(tagIndexAddress - base_address); CalculatePartitionOffsets(); }
public override void Read(BlamLib.IO.EndianReader s) { CacheFile cache = s.Owner as CacheFile; tagsOffset = (uint)(cache.Header.OffsetToIndex + cache.HeaderHalo2.IndexStreamSize); bool is_alpha = cache.EngineVersion == BlamVersion.Halo2_Alpha; bool is_echo = cache.EngineVersion == BlamVersion.Halo2_Epsilon; bool is_pc = cache.EngineVersion == BlamVersion.Halo2_PC; bool is_mp = cache.HeaderHalo2.CacheType == CacheType.Multiplayer; Managers.BlamDefinition bdef = Program.GetManager(cache.EngineVersion); uint tags_addressmask; if (!is_pc) { cache.AddressMask = bdef[cache.EngineVersion].CacheTypes.BaseAddress - (uint)cache.Header.OffsetToIndex; tags_addressmask = (uint)(cache.Header.OffsetToIndex + cache.HeaderHalo2.IndexStreamSize); } else { // pc maps use virtual addresses which are actually offsets relative to // the start of the tag memory buffer. since these are offsets and not actually // addresses which we would normally mask the base off of, we have to do some // number magic so our subtraction operations actually end up working in reverse // to get the correct file offset tags_addressmask = 0 - (uint)cache.Header.OffsetToIndex; cache.AddressMask = tags_addressmask; } #region version dependant loading if (is_alpha) { groupTagsAddress = address = s.ReadUInt32(); groupTagsCount = 0; scenario.Read(s); s.ReadInt32(); // crc tagCount = s.ReadInt32(); items = new CacheItem[tagCount]; s.ReadInt32(); // 'tags' } else if (is_pc) { groupTagsAddress = s.ReadPointer(); // offset (relative to the tag index offset) groupTagsCount = s.ReadInt32(); uint offset = s.ReadPointer(); // offset (relative to the tag index offset) to the tag entries scenario.Read(s); gameGlobals.Read(s); s.ReadInt32(); // crc tagCount = s.ReadInt32(); items = new CacheItem[tagCount]; s.ReadInt32(); // 'tags' s.Seek(offset /*- 32, System.IO.SeekOrigin.Current*/); // go to the first tag entry } else { groupTagsAddress = s.ReadUInt32(); groupTagsCount = s.ReadInt32(); address = s.ReadUInt32(); scenario.Read(s); gameGlobals.Read(s); s.ReadInt32(); // crc tagCount = s.ReadInt32(); items = new CacheItem[tagCount]; s.ReadInt32(); // 'tags' s.Seek(groupTagsCount * 12, System.IO.SeekOrigin.Current); // go to the first tag entry } this.groupTagsOffset = this.groupTagsAddress - s.BaseAddress; #endregion CacheItem item; uint temp_pos = 0; uint sbsp_offset = 0; DatumIndex[] ltmps = null; Tags.scenario_structure_bsp_reference_block bsp_block = new Tags.scenario_structure_bsp_reference_block(); if (is_pc) // MP maps need this adjustment { cache.AddressMask = tags_addressmask += cache.HeaderHalo2.PcFields.VirtualAddress; } for (int x = 0; x < items.Length; x++) { item = new CacheItem(); items[x] = item; if (is_alpha) { item.ReadAlpha(s); } else { item.Read(s); } if (item.Location == ItemLocation.Unknown) { items[x] = CacheItem.Null; } else if (is_pc && item.HasExternalData) { HasExternalTags = true; } } if (!is_pc) { // While the tag definitions come right after the tag header in a cache file, when // finally loaded into game memory this isn't the case. The 'stream' size of the tag // header is how much actual memory is used by map's generated the tag header, but the // map's tag header may not utilize the entire memory space dedicated to it in game memory. // So, the game would read the tag header data using the offset and 'stream' size data from // the cache header, then it would seek to offset+stream_size to get to the tag definitions // which it would then read into game memory at the memory location defined by 'address' tags_addressmask = items[0].Address - tags_addressmask; cache.AddressMask = tags_addressmask; for (int x = 0; x < items.Length; x++) { item = items[x]; item.Offset = (int)(item.Address - tags_addressmask); #region on scnr tag if (!is_alpha && !is_echo && TagGroups.scnr.ID == item.GroupTag.ID) { temp_pos = s.PositionUnsigned; //if (is_alpha || is_echo) // s.Seek(item.Offset + 828); //else s.Seek(item.Offset + 528); bspTags = new Item[s.ReadInt32()]; sbsp_offset = s.ReadPointer(); ltmps = new DatumIndex[bspTags.Length]; s.Seek(temp_pos); } #endregion #region on sbsp tag else if (!is_alpha && !is_echo && TagGroups.sbsp.ID == item.GroupTag.ID) { temp_pos = s.PositionUnsigned; s.Seek(sbsp_offset + (uint)(bspCount * Halo2.Tags.scenario_structure_bsp_reference_block.kRuntimeSizeOf)); bspTags[bspCount] = item; bsp_block.Read(cache); if (bsp_block.RuntimeOffset != 0) { item.Offset = bsp_block.RuntimeOffset; item.Size = bsp_block.RuntimeSize; item.Address = (uint)bsp_block.RuntimeAddress.Value; //cache.BspAddressMasks.Add((uint)(item.Address - item.Offset)); } ltmps[bspCount] = bsp_block.Lightmap.Datum; item.BspIndex = bspCount++; s.Seek(temp_pos); } #endregion } } #region alpha tag name code if (is_alpha) { // following the tag datums in alpha builds is the tag names buffer foreach (Halo2.CacheItem ci in items) { ci.TagNameOffset = s.PositionUnsigned; ci.ReferenceName = cache.References.AddOptimized(ci.GroupTag, s.ReadCString()); } } #endregion #region retail tag name & bsp offset fixup code else { // Build the absolute tag name offsets s.Seek(cache.HeaderHalo2.TagNameIndicesOffset); int[] offsets = new int[tagCount]; for (int x = 0; x < offsets.Length; x++) { int offset = s.ReadInt32(); // Offset will be -1 if the tag in question is 'null' if (offset != -1) { offset += cache.HeaderHalo2.TagNamesBufferOffset; } offsets[x] = offset; } // Fixup all tag instances which are named for (int x = 0; x < tagCount; x++) { if (offsets[x] != -1) { FixupTagInstanceHeaderName(cache, items[x], offsets[x], s); } } // PC maps store all zones in the tag memory, they don't need to swap out and thus don't // need any fix ups (durrr, PCs have loltons of RAM) if (!is_pc && !is_echo) { var head = new Halo2.Tags.scenario_structure_bsps_header(); foreach (CacheItem tmp_item in bspTags) { s.Seek(tmp_item.Offset); head.Read(cache); // bsp uint bsp_address_mask = head.FixupBspInstanceHeader(tmp_item, s.Position); cache.BspAddressMasks.Add(bsp_address_mask); // ltmp DatumIndex ltmp_datum = ltmps[tmp_item.BspIndex]; if (ltmp_datum != DatumIndex.Null) { head.FixupLightmapInstanceHeader(this.items[ltmp_datum.Index], tmp_item); } } } } #endregion }