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...
		}

			/// <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;
		}

			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 = "";
		}