internal override bool Reconstruct(BlamLib.Blam.CacheFile c) { //int index = BitmapGroup.Value & 0xFFFF; //if (index != -1) System.Diagnostics.Debug.WriteLine(string.Format( // "BitmapGroup: {0} {1}", index, c.Index.Tags[index].FileName)); return true; }
protected override void ProcessDefinition(XmlNode node, BlamLib.CheApe.ProjectState state, BlamLib.IO.XmlStream s) { StringIdFieldsInitialize(state); switch (node.Name) { #region Tag Structs case "structs": s.SaveCursor(node); ProcessTagStructs(state, s); s.RestoreCursor(); break; #endregion #region Tag Blocks case "blocks": s.SaveCursor(node); ProcessTagBlocks(state, s); s.RestoreCursor(); break; #endregion #region Tag Groups case "groups": s.SaveCursor(node); ProcessTagGroups(state, s); s.RestoreCursor(); break; #endregion } }
public void Write(BlamLib.IO.EndianWriter s) { if(nullBuffer == null) nullBuffer = new byte[ByteCount]; s.Write(nullBuffer); }
/// <summary>Initialize state for processing a tag hierarchy</summary> /// <param name="args"></param> /// <param name="instance"></param> public void InitializeStateForTagHierarchy(BlamLib.Blam.CacheExtractionArguments args, BlamLib.Blam.CacheIndex.Item instance) { m_sender = TagExtractionSender.TagTree; Arguments = args; Instance = instance; }
public override void Read(BlamLib.IO.EndianReader s) { Blam.CacheFile.ValidateHeader(s, 0x800); s.Seek(4); version = s.ReadInt32(); if (version != 5) throw new InvalidCacheFileException(s.FileName); fileLength = s.ReadInt32(); int xbox = s.ReadInt32(); // Xbox only field offsetToIndex = s.ReadInt32(); s.ReadInt32(); // stream size s.ReadInt32(); s.ReadInt32(); name = s.ReadTagString(); build = s.ReadTagString(); // Xbox only field. Always '400' cacheType = (CacheType)s.ReadInt16(); s.ReadInt16(); s.ReadInt32(); // CRC s.Seek((485 * sizeof(int)) + sizeof(uint), System.IO.SeekOrigin.Current); CacheFile cf = s.Owner as CacheFile; if (xbox != 0) cf.EngineVersion = BlamVersion.Stubbs_Xbox; else // no way to tell when it's mac, which just seems to use PC maps anyway (byte swaps everything when map is loaded) cf.EngineVersion = BlamVersion.Stubbs_PC; }
public CheApe(BlamLib.BlamVersion engine) { InitializeComponent(); MainMenu.Renderer = MainForm.kOpenSauceIDEToolStripRenderer; FileViewMenu.Renderer = MainForm.kOpenSauceIDEToolStripRenderer; SetState(false); #region FileViewRoot this.FileViewRoot = new System.Windows.Forms.TreeNode("Project Files"); FileViewRoot.ContextMenuStrip = this.FileViewMenu; FileViewRoot.Name = "FileViewRoot"; this.FileView.Nodes.Add(FileViewRoot); #endregion OpenDialog.DefaultExt = kFileExt; OpenDialog.Filter = kFileFilter; SaveDialog.DefaultExt = kFileExt; SaveDialog.Filter = kFileFilter; OpenProjDialog.Multiselect = false; OpenProjDialog.Filter = BlamLib.IO.TagGroups.CheApeProject.Filter; SaveProjDialog.Filter = BlamLib.IO.TagGroups.CheApeProject.Filter; ProjectInterface = BlamLib.CheApe.Project.GetInterface(engine); }
public override void Read(BlamLib.IO.EndianReader s) { Blam.CacheFile.ValidateHeader(s, 0x800); s.Seek(4); s.ReadInt32(); // version, should be 5 fileLength = s.ReadInt32(); int xbox = s.ReadInt32(); // Xbox only field offsetToIndex = s.ReadInt32(); s.ReadInt32(); // stream size s.ReadInt32(); s.ReadInt32(); name = s.ReadTagString(); build = s.ReadTagString(); // Xbox only field. Always '400' cacheType = (CacheType)s.ReadInt32(); s.ReadInt32(); // CRC s.Seek((485 * sizeof(int)) + sizeof(uint), System.IO.SeekOrigin.Current); CacheFile cf = s.Owner as CacheFile; if (xbox != 0) cf.EngineVersion = BlamVersion.Stubbs_Xbox; else cf.EngineVersion = BlamVersion.Stubbs_PC; // no way to tell when its mac... }
public override void Read(BlamLib.IO.EndianReader s) { int pos = 0; Blam.CacheFile.ValidateHeaderAdjustEndian(s, 0x800); s.Seek(4); Halo1.Version ver = (Halo1.Version)(version = s.ReadInt32()); fileLength = s.ReadInt32(); if (fileLength < s.Length) throw new Debug.ExceptionLog("Compressed map editing not available yet!"); s.ReadInt32(); if (ver == Halo1.Version.PC_Demo) { pos = s.Position; s.Position = 0x5EC; offsetToIndex = s.ReadInt32(); s.Position = pos; } else offsetToIndex = s.ReadInt32(); tagBufferSize = s.ReadInt32(); s.ReadInt32(); s.ReadInt32(); if (ver == Halo1.Version.PC_Demo) { pos = s.Position; s.Position = 0x5E8; name = s.ReadTagString(); s.Position = pos; } else name = s.ReadTagString(); build = s.ReadTagString(); cacheType = (CacheType)s.ReadInt16(); s.ReadInt16(); s.ReadInt32(); // CRC s.ReadInt32(); s.Seek((484 * sizeof(int)) + sizeof(uint), System.IO.SeekOrigin.Current); CacheFile cache = s.Owner as CacheFile; if (ver == Halo1.Version.Xbox) cache.EngineVersion = BlamVersion.Halo1_Xbox; else if (ver == Halo1.Version.PC || ver == Halo1.Version.PC_Demo) { if(s.State == IO.EndianState.Big) cache.EngineVersion = BlamVersion.Halo1_XboxX; else { // Interestingly, HaloPC is build 01.00.00.0564, HA10 is build 01.00.01.0563 // Little if(build == "01.00.01.0563") cache.EngineVersion = BlamVersion.Halo1_PCX; else cache.EngineVersion = BlamVersion.Halo1_PC; } } else if (ver == Halo1.Version.CE) cache.EngineVersion = BlamVersion.Halo1_CE; }
/// <summary>Initialize state for processing a single tag</summary> /// <param name="instance"></param> /// <param name="base_dir"></param> /// <param name="name_override"></param> public void InitializeStateForTagInstance(BlamLib.Blam.CacheIndex.Item instance, string base_dir, string name_override) { m_sender = TagExtractionSender.TagInstance; Instance = instance; BaseDirectory = base_dir; NameOverride = name_override; }
void StringIdFieldsInitialize(BlamLib.CheApe.ProjectState state) { if (StringIdFieldDefinition != null) return; // Will add itself to the import state in the ctor StringIdFieldDefinition = new TagReference(state, kStringIdFieldDefinitionName, true, kStringIdGroupTag); StringIdFieldHandlePadding = new Field(state, state.kTypeIndexPad, "", kStringIdPadSize.ToString()); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Gets the shader data from the tag. </summary> /// /// <param name="tagIndex"> The parent tag index. </param> /// <param name="tagManager"> The tags' manager. </param> /// /// <returns> The shader data. </returns> private ModelShaderData GetShaderData(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager) { var data = new ModelShaderData(); data.CollectData(tagIndex, tagManager); return data; }
internal override bool Reconstruct(BlamLib.Blam.CacheFile c) { //PredictedResources.DeleteAll(); //EditorScenarioData.Delete(); LevelData.DeleteAll(); //SharedReferences.DeleteAll(); //SimulationDefinitionTable.DeleteAll(); return true; }
internal byte[] CacheRead(BlamLib.Blam.CacheFile c) { // read the cache block... byte[] bytes; if (!CacheRead(c, out bytes)) return null; if (c.EngineVersion == BlamVersion.Halo2_PC) // ...and perform zlib decompression bytes = Util.ZLibBufferFromBytes(bytes, 0, GetPixelDataSize(c.EngineVersion)); return bytes; }
int CalculateSize(BlamLib.CheApe.ProjectState state, Field f) { int size = 0; if (f.TypeIndex == state.kTypeIndexPad || f.TypeIndex == state.kTypeIndexSkip) size = f.ToInt(); else size = state.GetFieldSize(f.TypeIndex); return size; }
int CalculateSize(BlamLib.CheApe.ProjectState state, Field f, int kUselessPadTypeIndex) { if (f.TypeIndex == state.kTypeIndexPad || f.TypeIndex == kUselessPadTypeIndex || f.TypeIndex == state.kTypeIndexSkip) return f.ToInt(); //else if (f.TypeIndex == kStructTypeIndex) // ((Struct)state.ImportedBlocks[f.ToString()]).Block.Latest.CalculateSize(); else return state.GetFieldSize(f.TypeIndex); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Gets the scenario data from the tag. </summary> /// /// <param name="tagIndex"> Zero-based index of the tag. </param> /// <param name="tagManager"> The tag's manager. </param> /// /// <returns> The scenario data. </returns> private ScenarioData GetScenarioData(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager) { var data = new ScenarioData(); data.MessageSent += MessageRedirect; data.CollectData(tagIndex, tagManager); data.MessageSent -= MessageRedirect; return data; }
public CacheView(BlamLib.BlamVersion engine) { InitializeComponent(); MainMenu.Renderer = MainForm.kOpenSauceIDEToolStripRenderer; MenuTagInstance.Renderer = MainForm.kOpenSauceIDEToolStripRenderer; m_tagTreeEditorMode = TagTreeEditorMode.TagExtraction; m_engine = engine; m_cache = null; bool tag_extraction_supported = (engine & kAllowedPlatforms) != 0; ViewUpdateExtractionSupportedState(tag_extraction_supported, false); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Gets the BSP data from the tag. </summary> /// /// <param name="tagIndex"> The parent tag index. </param> /// <param name="tagManager"> The tag's manager. </param> /// /// <returns> The bsp data. </returns> private StructureBSPData GetBSPData(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager) { var data = new StructureBSPData() { IncludeRenderMesh = mBspData.ExportRenderMesh, IncludePortals = mBspData.ExportPortals, IncludeFogPlanes = mBspData.ExportFogPlanes, IncludeBSPMarkers = mBspData.ExportBSPMarkers }; data.CollectData(tagIndex, tagManager); return data; }
/// <summary> /// Calculates the block size in bytes via the field for this block /// eliminating the need for programmers to aid designers in creating /// the tag group definition files /// </summary> /// <returns></returns> public int CalculateSize(BlamLib.CheApe.ProjectState state) { int size = 0; for (int x = 0; x < fields.Count; x++) { if (fields[x].TypeIndex == state.kTypeIndexArrayStart) size += CalculateSizeFromArrayStart(state, ref x); else size += CalculateSize(state, fields[x]); } return size; }
int CalculateSizeFromArrayStart(BlamLib.CheApe.ProjectState state, ref int current_index) { int array_size = 0; int array_count = fields[current_index++].ToInt(); for (; ; current_index++) if (fields[current_index].TypeIndex == state.kTypeIndexArrayStart) array_size += CalculateSizeFromArrayStart(state, ref current_index); else if (fields[current_index].TypeIndex == state.kTypeIndexArrayEnd) break; else array_size += CalculateSize(state, fields[current_index]); return array_size * array_count; }
internal override bool Reconstruct(BlamLib.Blam.CacheFile c) { bool result = true; if (ParticleSystemData.Count != 1) { particle_system_lite_data_block data; ParticleSystemData.Add(out data); result = data.Reconstruct(GeometryBlockInfo.Value); } GeometryBlockInfo.Value.ClearPostReconstruction(); return result; }
void OnTagInstanceExtractAs(BlamLib.Blam.CacheIndex.Item tag_instance) { SaveFileDlg.Filter = tag_instance.GroupTag.Filter; if (SaveFileDlg.ShowDialog(this) == DialogResult.OK) { string path = SaveFileDlg.FileName; var tiei = new TagInstanceExtractionInfo(); tiei.InitializeStateForTagInstance(tag_instance, System.IO.Path.Combine(System.IO.Path.GetDirectoryName(path), @"\"), System.IO.Path.GetFileNameWithoutExtension(path)); tiei.InitializeExtractionForTagInstance(); bgwTagExtract.RunWorkerAsync(tiei); } SaveFileDlg.Filter = ""; }
internal override bool Reconstruct(BlamLib.Blam.CacheFile c) { bool result = true; // recreate the section data if (RenderData.Count != 1) { structure_bsp_cluster_data_block_new cdata; RenderData.Add(out cdata); result = cdata.Section.Value.Reconstruct(c, SectionInfo.Value, GeometryBlockInfo.Value); } GeometryBlockInfo.Value.ClearPostReconstruction(); return result; }
internal override bool Reconstruct(BlamLib.Blam.CacheFile c) { bool result = true; // recreate the section data if (CacheBlockData.Count != 1) { decorator_cache_block_data_block cdata; CacheBlockData.Add(out cdata); result = cdata.Reconstruct(GeometryBlockInfo.Value); } GeometryBlockInfo.Value.ClearPostReconstruction(); return result; }
/// <summary> /// Calculates the block size in bytes via the field for this block /// eliminating the need for programmers to aid designers in creating /// the tag group definition files /// </summary> /// <returns></returns> public int CalculateSize(BlamLib.CheApe.ProjectState state) { int size = 0; int kUselessPadTypeIndex = state.Definition.GetTypeIndex("UselessPad"); //int kStructTypeIndex = state.Definition.GetTypeIndex("Struct"); for (int x = 0; x < fields.Count; x++) { if (fields[x].TypeIndex == state.kTypeIndexArrayStart) size += CalculateSizeFromArrayStart(state, ref x, kUselessPadTypeIndex); else size += CalculateSize(state, fields[x], kUselessPadTypeIndex); } return size; }
void OnApply(BlamLib.BlamVersion v) { Exception exception = null; CheApeInterface.UnlockToolsBase unlocker = null; switch(v) { case BlamLib.BlamVersion.Halo1_CE: try { unlocker = new CheApeInterface.UnlockH1(txtPathOutput.Text, txtPathGuerilla.Text, txtPathTool.Text, txtPathSapien.Text); } catch (Exception ex) { exception = ex; } break; case BlamLib.BlamVersion.Halo2_PC: try { unlocker = new CheApeInterface.UnlockH2(txtPathOutput.Text, txtPathGuerilla.Text, txtPathTool.Text, txtPathSapien.Text); } catch (Exception ex) { exception = ex; } break; default: MessageBox.Show(this, string.Format("the quarter ({0}) isn't under any of the cups you f****n cheater i kill you", cbEngineVersion.SelectedText), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } if (unlocker != null) // If the unlocker api was initialized OK, run the unlocking operations { try { unlocker.Unlock(false); unlocker.Close(); } catch (Exception ex) { exception = ex; } } if (exception != null) OnApplyException(v, exception); string msg = exception == null ? "CheApe successfully applied!" : "There was an error while trying to apply CheApe. Validate that you selected copies of the original tools and try again."; if (unlocker.EncounteredInvalidExe) OnApplyMsg(true, "CheApe couldn't be applied to some or all of the exes. Check the debug log for more details"); else OnApplyMsg(exception != null, msg); }
public void Read(BlamLib.CheApe.ProjectState state, IO.XmlStream s) { int array_start_depth = 0; foreach (XmlNode n in s.Cursor.ChildNodes) { if (n.Name != "field") continue; Field f; s.SaveCursor(n); fields.Add(f = new Field(state, s)); s.RestoreCursor(); if (f.TypeIndex == state.kTypeIndexArrayStart) array_start_depth++; else if (f.TypeIndex == state.kTypeIndexArrayEnd) array_start_depth--; } if (array_start_depth != 0) throw new Debug.ExceptionLog("Unterminated ArrayStart or extra ArrayEnd in '{0}'.{1}{2}", s.FileName, Program.NewLine, s.Cursor.OuterXml); }
public CheApeApplier(BlamLib.BlamVersion version) { InitializeComponent(); cbEngineVersion.Items.Add(BlamLib.BlamVersion.Halo1_CE); cbEngineVersion.Items.Add(BlamLib.BlamVersion.Halo2_PC); // NOTE: this isn't the best control logic for this. Will probably want to change this later if (version == BlamLib.BlamVersion.Halo1_CE) cbEngineVersion.SelectedIndex = 0; else if (version == BlamLib.BlamVersion.Halo2_PC) cbEngineVersion.SelectedIndex = 1; // txtPathOutput.Text = @"C:\Mount\B\Kornner\Projects\bin\_Halo1\"; // txtPathGuerilla.Text = @"C:\Program Files (x86)\Microsoft Games\Halo Custom Edition\guerilla.exe"; // txtPathTool.Text = @"C:\Program Files (x86)\Microsoft Games\Halo Custom Edition\tool.exe"; // txtPathSapien.Text = @"C:\Program Files (x86)\Microsoft Games\Halo Custom Edition\sapien.exe"; // txtPathOutput.Text = @"C:\Mount\B\Kornner\Projects\bin\_Halo2\"; // txtPathGuerilla.Text = @"C:\Program Files (x86)\Microsoft Games\Halo 2 Map Editor\H2Guerilla.exe"; // txtPathTool.Text = @"C:\Program Files (x86)\Microsoft Games\Halo 2 Map Editor\H2Tool.exe"; // txtPathSapien.Text = @"C:\Program Files (x86)\Microsoft Games\Halo 2 Map Editor\H2Sapien.exe"; }
bool CacheRead(BlamLib.Blam.CacheFile c, out byte[] data) { data = null; ResourcePtr offset = GetOffset(0); int size = GetSize(0); var rsrc_cache = Program.Halo2.FromLocation(c as Halo2.CacheFile, offset); // the shared cache isn't loaded, break if (rsrc_cache == null) return false; // get the input stream we need IO.EndianReader er = rsrc_cache.InputStream; // read the bitmap er.Seek(offset.Offset); data = er.ReadBytes(size); return true; }
public static string ReadCString(uint offset, BlamLib.IO.EndianReader io) { if (offset == 0) return string.Empty; uint pos = io.PositionUnsigned; io.Seek(offset); byte btchar = 0; var cstring = new System.Text.StringBuilder(); do { btchar = io.ReadByte(); if (btchar != 0) cstring.Append((char)btchar); } while (btchar != 0); io.Seek(pos); return cstring.ToString(); }