private void SaveDefinitionFixups(IList <ResourceDefinitionFixup> fixups, StructureValueCollection values, IStream stream, TagBlockCache <ResourceDefinitionFixup> cache) { var oldCount = (int)values.GetIntegerOrDefault("number of definition fixups", 0); uint oldAddress = (uint)values.GetIntegerOrDefault("definition fixup table address", 0); long oldExpand = _expander.Expand(oldAddress); StructureLayout layout = _buildInfo.Layouts.GetLayout("definition fixup element"); long newAddress; if (!cache.TryGetAddress(fixups, out newAddress)) { // Write a new block IEnumerable <StructureValueCollection> entries = fixups.Select(f => SerializeDefinitionFixup(f)); newAddress = TagBlockWriter.WriteTagBlock(entries, oldCount, oldExpand, fixups.Count, layout, _metaArea, _allocator, stream); cache.Add(newAddress, fixups); } else if (oldAddress != 0 && oldCount > 0) { // Block was cached - just free it _allocator.Free(oldExpand, oldCount * layout.Size); } uint cont = _expander.Contract(newAddress); values.SetInteger("number of definition fixups", (uint)fixups.Count); values.SetInteger("definition fixup table address", cont); }
private void SaveSizeParts(IList <ResourceSizePart> parts, StructureValueCollection values, IStream stream, TagBlockCache <ResourceSizePart> cache) { var oldCount = (int)values.GetIntegerOrDefault("number of size parts", 0); uint oldAddress = (uint)values.GetIntegerOrDefault("size part table address", 0); long expand = _expander.Expand(oldAddress); StructureLayout layout = _buildInfo.Layouts.GetLayout("size part table element"); long newAddress; if (!cache.TryGetAddress(parts, out newAddress)) { // Write a new block IEnumerable <StructureValueCollection> entries = parts.Select(p => SerializeSizePart(p)); newAddress = TagBlockWriter.WriteTagBlock(entries, oldCount, expand, parts.Count, layout, _metaArea, _allocator, stream); cache.Add(newAddress, parts); } else if (oldAddress != 0 && oldCount > 0) { // Block was cached - just free it _allocator.Free(expand, oldCount * layout.Size); } uint cont = _expander.Contract(newAddress); values.SetInteger("number of size parts", (uint)parts.Count); values.SetInteger("size part table address", cont); }
public void SaveSizes(ICollection <ResourceSize> sizes, IStream stream) { StructureValueCollection values = LoadTag(stream); var entries = new List <StructureValueCollection>(); var partCache = new TagBlockCache <ResourceSizePart>(); foreach (ResourceSize size in sizes) { StructureValueCollection entry = SerializeSize(size); entries.Add(entry); SaveSizeParts(size.Parts, entry, stream, partCache); } StructureLayout layout = _buildInfo.Layouts.GetLayout("raw size table element"); var oldCount = (int)values.GetInteger("number of raw sizes"); uint oldAddress = (uint)values.GetInteger("raw size table address"); long expand = _expander.Expand(oldAddress); long newAddress = TagBlockWriter.WriteTagBlock(entries, oldCount, expand, sizes.Count, layout, _metaArea, _allocator, stream); // Update values uint cont = _expander.Contract(newAddress); values.SetInteger("number of raw sizes", (uint)sizes.Count); values.SetInteger("raw size table address", cont); SaveTag(values, stream); }
/// <summary> /// Saves changes made to zone sets in the table. /// </summary> /// <param name="stream">The stream to write to.</param> /// <exception cref="System.NotImplementedException"></exception> public void SaveChanges(IStream stream) { StructureValueCollection tagValues = _gestalt.LoadTag(stream); FreeZoneSets(tagValues, stream); var cache = new TagBlockCache <int>(); SaveZoneSetTable(GlobalZoneSet, tagValues, "number of global zone sets", "global zone set table address", cache, stream); SaveZoneSetTable(UnattachedZoneSet, tagValues, "number of unattached zone sets", "unattached zone set table address", cache, stream); SaveZoneSetTable(DiscForbiddenZoneSet, tagValues, "number of disc forbidden zone sets", "disc forbidden zone set table address", cache, stream); SaveZoneSetTable(DiscAlwaysStreamingZoneSet, tagValues, "number of disc always streaming zone sets", "disc always streaming zone set table address", cache, stream); SaveZoneSetTable(RequiredMapVariantsZoneSet, tagValues, "number of required map variant zone sets", "required map variant zone set table address", cache, stream); SaveZoneSetTable(SandboxMapVariantsZoneSet, tagValues, "number of sandbox map variant zone sets", "sandbox map variant zone set table address", cache, stream); SaveZoneSetTable(GeneralZoneSets, tagValues, "number of general zone sets", "general zone set table address", cache, stream); SaveZoneSetTable(BSPZoneSets, tagValues, "number of bsp zone sets", "bsp zone set table address", cache, stream); SaveZoneSetTable(BSPZoneSets2, tagValues, "number of bsp 2 zone sets", "bsp 2 zone set table address", cache, stream); SaveZoneSetTable(BSPZoneSets3, tagValues, "number of bsp 3 zone sets", "bsp 3 zone set table address", cache, stream); SaveZoneSetTable(CinematicZoneSets, tagValues, "number of cinematic zone sets", "cinematic zone set table address", cache, stream); SaveZoneSetTable(ScenarioZoneSets, tagValues, "number of scenario zone sets", "scenario zone set table address", cache, stream); _gestalt.SaveTag(tagValues, stream); }
private void SaveZoneSetTable(IZoneSet[] sets, StructureValueCollection tagValues, string countName, string addressName, TagBlockCache <int> cache, IStream stream) { if (!tagValues.HasInteger(countName) || !tagValues.HasInteger(addressName)) { return; } var count = (int)tagValues.GetInteger(countName); if (count != sets.Length) { throw new InvalidOperationException("Zone set count does not match"); } uint address = (uint)tagValues.GetInteger(addressName); long expand = _expander.Expand(address); StructureLayout layout = _buildInfo.Layouts.GetLayout("zone set definition"); List <StructureValueCollection> entries = sets.Select(set => ((ThirdGenZoneSet)set).Serialize(stream, _allocator, cache, _expander)).ToList(); TagBlockWriter.WriteTagBlock(entries, expand, layout, _metaArea, stream); }
private void SaveZoneSetTable(IZoneSet set, StructureValueCollection tagValues, string countName, string addressName, TagBlockCache <int> cache, IStream stream) { SaveZoneSetTable(new[] { set }, tagValues, countName, addressName, cache, stream); }
public IList <ResourcePointer> SaveResources(ICollection <Resource> resources, IStream stream) { StructureValueCollection values = LoadTag(stream); StructureLayout layout = _buildInfo.Layouts.GetLayout("resource table element"); FreeResources(values, stream); FreeInfoBuffer(values); // Serialize each resource element // This can't be lazily evaluated because allocations might cause the stream to expand int infoOffset = 0; int altInfoOffset = 0; var infocache = new TagBlockCache <int>(); var pointers = new List <ResourcePointer>(); var entries = new List <StructureValueCollection>(); var fixupCache = new TagBlockCache <ResourceFixup>(); var defFixupCache = new TagBlockCache <ResourceDefinitionFixup>(); List <byte[]> paddedInfos = new List <byte[]>(); foreach (Resource resource in resources) { StructureValueCollection entry = SerializeResource(resource, (resource.Location != null) ? pointers.Count : -1, stream); entries.Add(entry); // Save fixups SaveResourceFixups(resource.ResourceFixups, entry, stream, fixupCache); SaveDefinitionFixups(resource.DefinitionFixups, entry, stream, defFixupCache); uint bits = (uint)entry.GetInteger("resource bits"); int size = (int)entry.GetInteger("resource info size"); List <int> offsets = new List <int>(); if (size > 0) { int dirtyoffset = infoOffset; infoOffset = AlignInfoBlockOffset(resource, infoOffset); offsets.Add(infoOffset); int padding = infoOffset - dirtyoffset; byte[] temp = new byte[padding + size]; Buffer.BlockCopy(resource.Info, 0, temp, padding, size); paddedInfos.Add(temp); infoOffset += size; } else { offsets.Add(0); } if ((bits & 2) > 0) { int tempalt = AlignInfoBlockOffset(resource, altInfoOffset); offsets.Add(tempalt); altInfoOffset += size; } else { offsets.Add(size > 0 ? -1 : 0); } if ((bits & 4) > 0) { int tempalt = AlignInfoBlockOffset(resource, altInfoOffset); offsets.Add(tempalt); altInfoOffset += size; } else { offsets.Add(size > 0 ? -1 : 0); } if (layout.HasField("number of resource info offsets")) { var oldCount = (int)entry.GetIntegerOrDefault("number of resource info offsets", 0); uint oldAddress = (uint)entry.GetIntegerOrDefault("resource info offsets table address", 0); long expand = _expander.Expand(oldAddress); StructureLayout infolayout = _buildInfo.Layouts.GetLayout("resource info offset element"); if (size > 0) { long newBlockAddress; // Write a new block IEnumerable <StructureValueCollection> infoentries = offsets.Select(f => SerializeInfos(f)); newBlockAddress = TagBlockWriter.WriteTagBlock(infoentries, oldCount, expand, offsets.Count, infolayout, _metaArea, _allocator, stream); infocache.Add(newBlockAddress, offsets); uint cont = _expander.Contract(newBlockAddress); entry.SetInteger("number of resource info offsets", (uint)offsets.Count); entry.SetInteger("resource info offsets table address", cont); } else { entry.SetInteger("number of resource info offsets", 0); entry.SetInteger("resource info offsets table address", 0); } } else { if (size > 0) { entry.SetInteger("resource info offset", (uint)offsets[0]); entry.SetInteger("alt resource info offset", (uint)offsets[1]); } else { entry.SetInteger("resource info offset", 0); entry.SetInteger("alt resource info offset", 0); } } // Update pointer info if (resource.Location != null) { pointers.Add(resource.Location); } } // Write the block and update the tag values long newAddress = TagBlockWriter.WriteTagBlock(entries, layout, _metaArea, _allocator, stream); uint contr = _expander.Contract(newAddress); values.SetInteger("number of resources", (uint)entries.Count); values.SetInteger("resource table address", contr); // Save the info buffer SaveResourceInfoBuffer(paddedInfos.SelectMany(a => a).ToArray(), values, stream); SaveTag(values, stream); return(pointers); }
private void SaveBitArray(BitArray bits, string countName, string addressName, MetaAllocator allocator, IStream stream, TagBlockCache <int> cache, StructureValueCollection values, IPointerExpander expander) { if (bits.Length == 0) { values.SetInteger(countName, 0); values.SetInteger(addressName, 0); return; } var ints = bits.ToIntArray(); // If the address isn't cached, then allocate space and write a new array long newAddress; if (!cache.TryGetAddress(ints, out newAddress)) { newAddress = allocator.Allocate(ints.Length * 4, stream); stream.SeekTo(_metaArea.PointerToOffset(newAddress)); foreach (int i in ints) { stream.WriteInt32(i); } cache.Add(newAddress, ints); } uint cont = expander.Contract(newAddress); values.SetInteger(countName, (uint)ints.Length); values.SetInteger(addressName, cont); }
public StructureValueCollection Serialize(IStream stream, MetaAllocator allocator, TagBlockCache <int> cache, IPointerExpander expander) { var result = new StructureValueCollection(); SaveBitArray(_activeResources, "number of raw pool flags", "raw pool flag table address", allocator, stream, cache, result, expander); SaveBitArray(_unknownResources, "number of raw pool 2 flags", "raw pool 2 flag table address", allocator, stream, cache, result, expander); SaveBitArray(_unknownResources2, "number of raw pool 3 flags", "raw pool 3 flag table address", allocator, stream, cache, result, expander); SaveBitArray(_activeTags, "number of tag flags", "tag flag table address", allocator, stream, cache, result, expander); SaveBitArray(_unknownTags, "number of tag 2 flags", "tag 2 flag table address", allocator, stream, cache, result, expander); return(result); }