void ExtractWriteTagDatabase(Blam.CacheExtractionInfo cei, TagManager root_tag,
                                     TagInterface.TagGroup database_group,
                                     TagInterface.Definition db_definition, bool is_error_db)
        {
            if ((db_definition as ITagDatabase).IsEmpty)
            {
                return;
            }

            // name the database after the root tag we're extracting
            string tag_name = root_tag.Name;

            if (is_error_db)
            {
                tag_name = string.Format("{0}.errors", tag_name);
            }

            Blam.CacheIndex.Item tdb_item;
            // Just in-case someone tries to extract the same root tag twice
            if (!cacheFile.TryAndFind(tag_name, database_group, out tdb_item))
            {
                tdb_item = cacheFile.AddFeignTagInstance(tag_name, database_group);

                if (tdb_item == null)
                {
                    extractionTrace.WriteLine("Couldn't create a tag_database for {0}! Couldn't create tag entry for database",
                                              root_tag.Name);
                    return;
                }
            }

            try
            {
                var tdb_index = this.Open(tdb_item.Datum);

                var tdb = this[tdb_index];
                tdb.Manage(db_definition);

                // Even though the tag isn't actually in the cache, the tag
                // manager needs to operate this way with CacheTagIndex elements
                tdb.OpenForExtract(cei.Arguments.OutputDirectory, null);
                tdb.Extract();

                tdb.Close();
                Unload(tdb_index);
            }
            catch (Exception ex)
            {
                extractionTrace.WriteLine("Error while trying to write tag_database!");
                extractionTrace.WriteLine(ex);
            }
        }
        static void CacheLoadResourceSpecificXbox(string map)
        {
            using (var handler = new CacheHandler <Blam.Halo3.CacheFile>(BlamVersion.Halo3_Xbox, map))
            {
                handler.Read();
                var cache = handler.CacheInterface;

                var play_index = cache.TagIndexManager.OpenFirstInstance(Blam.Halo3.TagGroups.play);
                var playman    = cache.TagIndexManager[play_index];
                var playdef    = playman.TagDefinition as Blam.Halo3.Tags.cache_file_resource_layout_table_group;

                var zone_index = cache.TagIndexManager.OpenFirstInstance(Blam.Halo3.TagGroups.zone);
                var zoneman    = cache.TagIndexManager[zone_index];
                var zonedef    = zoneman.TagDefinition as Blam.Halo3.Tags.cache_file_resource_gestalt_group;

                if (map == kMapPathChillout)
                {
                    var sbsp_index = cache.TagIndexManager.Open(@"levels\dlc\chillout\chillout", BlamLib.Blam.Halo3.TagGroups.sbsp);
                    var sbspman    = cache.TagIndexManager[sbsp_index];
                    var sbspdef    = sbspman.TagDefinition as Blam.Halo3.Tags.scenario_structure_bsp_group;

                    Blam.DatumIndex         rsrc_index = sbspdef.BspRenderResourcesIndex.Value;
                    TagInterface.Definition rsrcdef    = zonedef.LoadResources(rsrc_index, cache, playdef.ResourceLayoutTable);
                    cache.TagIndexManager.Unload(sbsp_index);
                }

                if (map == kMapPathSandbox)
                {
                    var                     mode_index = cache.TagIndexManager.Open(@"objects\levels\dlc\shared\golf_club\fp_golf_club\fp_golf_club", Blam.Halo3.TagGroups.mode);
                    var                     modeman    = cache.TagIndexManager[mode_index];
                    var                     modedef    = modeman.TagDefinition as Blam.Halo3.Tags.render_model_group;
                    Blam.DatumIndex         rsrc_index = modedef.ResourceId.Value;
                    TagInterface.Definition rsrcdef    = zonedef.LoadResources(rsrc_index, cache, playdef.ResourceLayoutTable, true);

                    (rsrcdef as Blam.Cache.Tags.render_geometry_api_resource_definition).Debug(modeman,
                                                                                               Path.Combine(kTestResultsPath, "debug_render_geometry.txt"), true);

                    cache.TagIndexManager.Unload(mode_index);
                }

                playdef = null;
                cache.TagIndexManager.Unload(play_index);
                zonedef = null;
                cache.TagIndexManager.Unload(zone_index);
            }
        }
Beispiel #3
0
        private void UpdateField(int element, Field field, bool set_control)
        {
            if (element == -1)
            {
                return;
            }

            TagInterface.Definition elem = blockField.GetDefinition(element);

            // TODO: update this shit fool
//          try { elem[field.DefinitionIndex].DoDataExchange(field, set_control); }
//          catch (System.Exception ex)
//          {
//              Debug.LogFile.WriteLine(ex);
//              Debug.LogFile.WriteLine("Element index was: {0}", element);
//              Debug.LogFile.WriteLine("Field index was: {0}", field.DefinitionIndex);
//              Debug.LogFile.WriteLine("Data exchange between a '{0}' control and a '{1}' field failed on update of {2}", field.GetType(), elem[field.DefinitionIndex].GetType(), set_control ? "control" : "field data");
//          }
        }
        internal static void CacheExtractSoundMethod(object param)
        {
            var args = param as CacheFileOutputInfoArgs;

            using (var handler = new CacheHandler <Blam.Cache.CacheFileGen3>(args.Game, args.MapPath))
            {
                handler.Read();
                var cache = handler.CacheInterface;

                var play_index = cache.TagIndexManager.OpenFirstInstance(Blam.Halo3.TagGroups.play);
                var playman    = cache.TagIndexManager[play_index];
                var playdef    = playman.TagDefinition as Blam.Cache.Tags.cache_file_resource_layout_table_group;

                var zone_index = cache.TagIndexManager.OpenFirstInstance(Blam.Halo3.TagGroups.zone);
                var zoneman    = cache.TagIndexManager[zone_index];
                var zonedef    = zoneman.TagDefinition as Blam.Cache.Tags.cache_file_resource_gestalt_group;

                var ugh_index = cache.TagIndexManager.OpenFirstInstance(Blam.Halo3.TagGroups.ugh_);
                var ughman    = cache.TagIndexManager[ugh_index];
                var ughdef    = ughman.TagDefinition as Blam.Cache.Tags.sound_cache_file_gestalt_group_gen3;

                var snd_index = cache.TagIndexManager.Open(kSoundExtractionTagName, Blam.Halo3.TagGroups.snd_);
                var sndman    = cache.TagIndexManager[snd_index];
                var snddef    = sndman.TagDefinition as Blam.Cache.Tags.cache_file_sound_group_gen3;

                Blam.DatumIndex         rsrc_index = snddef.ResourceDatumIndex;
                TagInterface.Definition rsrcdef    = zonedef.LoadResources(rsrc_index, cache, playdef.GetResourceLayoutTable());

                ExtractSoundResource(Path.GetFileNameWithoutExtension(sndman.Name),
                                     ughdef, snddef, rsrcdef as Blam.Cache.Tags.sound_resource_definition);

                snddef = null;
                cache.TagIndexManager.Unload(snd_index);
                ughdef = null;
                cache.TagIndexManager.Unload(ugh_index);
                zonedef = null;
                cache.TagIndexManager.Unload(zone_index);
                playdef = null;
                cache.TagIndexManager.Unload(play_index);
            }

            args.SignalFinished();
        }