Ejemplo n.º 1
0
        public RenderMaterial(Direct3D.Device device, HaloOnlineCacheContext cacheContext, TagTool.Geometry.RenderMaterial material)
        {
            if (material.RenderMethod == null)
            {
                return;
            }

            using (var cacheStream = cacheContext.OpenTagCacheRead())
            {
                var renderMethod = (RenderMethod)cacheContext.Deserialize(
                    new TagSerializationContext(cacheStream, cacheContext, material.RenderMethod),
                    TagDefinition.Find(material.RenderMethod.Group));

                var template = cacheContext.Deserialize <RenderMethodTemplate>(
                    new TagSerializationContext(cacheStream, cacheContext, renderMethod.ShaderProperties[0].Template));

                Textures = new Dictionary <string, RenderTexture>();

                for (var shaderMapIndex = 0; shaderMapIndex < renderMethod.ShaderProperties[0].ShaderMaps.Count; shaderMapIndex++)
                {
                    var shaderMapName = cacheContext.GetString(template.SamplerArguments[shaderMapIndex].Name);

                    if (Textures.ContainsKey(shaderMapName))
                    {
                        continue;
                    }

                    var shaderMap           = renderMethod.ShaderProperties[0].ShaderMaps[shaderMapIndex];
                    var shaderMapDefinition = cacheContext.Deserialize <Bitmap>(new TagSerializationContext(cacheStream, cacheContext, shaderMap.Bitmap));

                    Textures[shaderMapName] = new RenderTexture(device, cacheContext, shaderMapDefinition, shaderMap.BitmapIndex);
                }
            }
        }
Ejemplo n.º 2
0
        public override object Deserialize(Stream stream, CachedTag instance)
        {
            var definitionType = TagDefinition.Find(instance.Group);
            var context        = new ModPackageTagSerializationContext(stream, this, BaseModPackage, (CachedTagHaloOnline)instance);

            return(Deserializer.Deserialize(context, definitionType));
        }
Ejemplo n.º 3
0
        private CachedTagInstance ConvertCachedTagInstance(ModPackageExtended modPack, CachedTagInstance modTag)
        {
            // Determine if tag requires conversion
            if (modPack.Tags.Index[modTag.Index] == null)
            {
                return(CacheContext.TagCache.Index[modTag.Index]);   // references an HO tag
            }
            else
            {
                // tag has already been converted
                if (TagMapping.ContainsKey(modTag.Index))
                {
                    return(CacheContext.TagCache.Index[TagMapping[modTag.Index]]);   // get the matching tag in the destination package
                }
                else
                {
                    CachedTagInstance newTag;
                    if (modTag.Index <= MagicNumber)
                    {
                        newTag = CacheContext.GetTag(modTag.Index);
                    }
                    else if (!CacheContext.TryGetTag($"{modTag.Name}.{modTag.Group}", out newTag))
                    {
                        newTag      = CacheContext.TagCache.AllocateTag(modTag.Group);
                        newTag.Name = modTag.Name;
                    }

                    TagMapping.Add(modTag.Index, newTag.Index);
                    var definitionType = TagDefinition.Find(modTag.Group.Tag);
                    var tagDefinition  = CacheContext.Deserialize(new ModPackageTagSerializationContext(modPack.TagsStream, CacheContext, modPack, modTag), definitionType);
                    tagDefinition = ConvertData(modPack, tagDefinition);

                    if (definitionType == typeof(ForgeGlobalsDefinition))
                    {
                        tagDefinition = ConvertForgeGlobals((ForgeGlobalsDefinition)tagDefinition);
                    }
                    else if (definitionType == typeof(Scenario))
                    {
                        tagDefinition = ConvertScenario(modPack, (Scenario)tagDefinition);
                    }
                    CacheContext.Serialize(CacheStream, newTag, tagDefinition);

                    foreach (var resourcePointer in modTag.ResourcePointerOffsets)
                    {
                        newTag.AddResourceOffset(resourcePointer);
                    }
                    return(newTag);
                }
            }
        }
Ejemplo n.º 4
0
        private bool GetShader(
            Mutex mutex,
            Stream stream,
            CachedTagInstance instance,
            IEnumerable <int> shader_rmdfs_ids,
            out RenderMethod rm_shader_definition,
            out Type rm_shader_type,
            out TagSerializationContext rm_shader_context,
            out string rmdf_name
            )
        {
            // get shader
            rm_shader_definition = null;
            rm_shader_type       = null;
            rm_shader_context    = null;
            rmdf_name            = null;
            {
                stream.Position   = 0;
                rm_shader_context = new TagSerializationContext(stream, CacheContext, instance);

                // if there is no dependency on the rmsh, early exit

                if (shader_rmdfs_ids != null && !rm_shader_context.Tag.Dependencies.Intersect(shader_rmdfs_ids).Any())
                {
                    mutex.ReleaseMutex();
                    return(true);
                }
                rm_shader_type       = TagDefinition.Find(rm_shader_context.Tag.Group.Tag);
                rm_shader_definition = CacheContext.Deserializer.Deserialize(rm_shader_context, rm_shader_type) as RenderMethod;
                // double check to make sure this is the correct render method definition
                if (shader_rmdfs_ids != null && !shader_rmdfs_ids.Contains(rm_shader_definition.BaseRenderMethod.Index))
                {
                    mutex.ReleaseMutex();
                    return(true);
                }

                var rmdf_index = rm_shader_definition.BaseRenderMethod.Index;
                rmdf_name = CacheContext.GetTag(rmdf_index)?.Name ?? rmdf_index.ToString("X");
            }

            return(false);
        }
Ejemplo n.º 5
0
        public override object Execute(List <string> args)
        {
            if (args.Count != 1)
            {
                return(false);
            }

            var destDir = new DirectoryInfo(args[0]);

            if (!destDir.Exists)
            {
                destDir.Create();
            }

            foreach (var entry in TagGroup.Instances)
            {
                if (entry.Key.Value == -1)
                {
                    continue;
                }

                var tagGroupName     = CacheContext.GetString(entry.Value.Name).ToSnakeCase();
                var tagStructureInfo = TagStructure.GetTagStructureInfo(TagDefinition.Find(entry.Key), CacheContext.Version);

                foreach (var type in tagStructureInfo.Types.Reverse <Type>())
                {
                    var info = type.GetCustomAttributes <TagStructureAttribute>(false).Where(attr =>
                                                                                             CacheVersionDetection.IsBetween(CacheContext.Version, attr.MinVersion, attr.MaxVersion)).First();

                    if (info.Name == null)
                    {
                        Console.WriteLine($"WARNING: {type.FullName} has no tag structure name defined!");
                        continue;
                    }

                    ExportType(type, new FileInfo(Path.Combine(destDir.FullName, $"{info.Name}.hpp")));
                }
            }

            return(true);
        }
Ejemplo n.º 6
0
        private void CopyTagNames(Stream cacheStream, CachedTagInstance edTag, CacheFile.IndexItem blamTag)
        {
            if (CopiedTags.ContainsKey(blamTag.GroupTag))
            {
                foreach (var name in CopiedTags[blamTag.GroupTag])
                {
                    if (name == blamTag.Name)
                    {
                        return;
                    }
                }
            }
            else
            {
                CopiedTags[blamTag.GroupTag] = new List <string>();
            }

            CopiedTags[blamTag.GroupTag].Add(blamTag.Name);

            var edDef   = CacheContext.Deserialize(cacheStream, edTag);
            var blamDef = BlamCache.Deserializer.Deserialize(
                new CacheSerializationContext(ref BlamCache, blamTag),
                TagDefinition.Find(blamTag.GroupTag));

            var edInfo   = TagStructure.GetTagStructureInfo(edDef.GetType(), CacheContext.Version);
            var blamInfo = TagStructure.GetTagStructureInfo(blamDef.GetType(), BlamCache.Version);

            var oldName = edTag.Name;

            edTag.Name = blamTag.Name;

            if (edTag.Name != oldName)
            {
                NewNameCount++;
            }

            CopyTagNames(cacheStream, edDef, edInfo, blamDef, blamInfo);
        }
Ejemplo n.º 7
0
        public void GetRMDF_IDs(string template_name, out IEnumerable <int> shader_rmdfs_ids, out Type template_type)
        {
            template_type    = null;
            shader_rmdfs_ids = null;

            IEnumerable <CachedTagInstance> shader_rmdfs = null;

            switch (template_name)
            {
            case "shader_templates":
            case "shader_template":
                template_type = typeof(Shader);
                //shader_rmdfs = CacheContext.TagNames.Where(item => item.Value == @"shaders\shader").Select(item => CacheContext.GetTag(item.Key)).ToList();
                break;

            case "cortana_templates":
            case "cortana_template":
                template_type = typeof(ShaderCortana);
                //shader_rmdfs = CacheContext.TagNames.Where(item => item.Value == @"shaders\cortana").Select(item => CacheContext.GetTag(item.Key)).ToList();
                break;

            case null:
            case "*":
                break;

            default:
                Console.WriteLine("Invalid template_type");
                break;
            }
            if (shader_rmdfs != null)
            {
                shader_rmdfs     = shader_rmdfs.Where(rmdf => TagDefinition.Find(rmdf.Group.Tag) == typeof(RenderMethodDefinition));
                shader_rmdfs_ids = shader_rmdfs.Select(rmdf => rmdf.Index);
                shader_rmdfs_ids = new int[] { shader_rmdfs_ids.FirstOrDefault() };
            }
        }
Ejemplo n.º 8
0
        public override object Execute(List <string> args)
        {
            if (args.Count < 1 || args.Count > 2)
            {
                return(false);
            }

begin:
            var groupTagString = args[0];

            if (groupTagString.Length > 4)
            {
                Console.WriteLine($"ERROR: Invalid group tag: {groupTagString}");
                return(true);
            }

            if (!Cache.TryParseGroupTag(groupTagString, out var groupTag))
            {
                var chars = new char[] { ' ', ' ', ' ', ' ' };

                for (var i = 0; i < chars.Length; i++)
                {
                    chars[i] = groupTagString[i];
                }

                groupTag = new Tag(new string(chars));
            }

            if (!TagGroup.Instances.ContainsKey(groupTag))
            {
                Console.WriteLine($"ERROR: No tag group definition for group tag '{groupTag}'!");
                Console.Write($"(BE CAREFUL WITH THIS!!!) Define '{groupTag}' tag group? [y/n]: ");

                var answer = Console.ReadLine().ToLower();

                if (answer != "y" && answer != "yes")
                {
                    return(true);
                }

                Console.WriteLine("Enter the tag group specification in the following format");
                Console.WriteLine("<group tag> [parent group tag] [grandparent group tag] <group name>:");
                Console.WriteLine();
                Console.Write($"{groupTag} specification> ");

                answer = Console.ReadLine();

                var groupArgs = ArgumentParser.ParseCommand(answer, out string redirect);

                switch (groupArgs.Count)
                {
                case 2: new TagGroup(new Tag(groupArgs[0]), Tag.Null, Tag.Null, Cache.StringTable.GetStringId(groupArgs[1])); break;

                case 3: new TagGroup(new Tag(groupArgs[0]), new Tag(groupArgs[1]), Tag.Null, Cache.StringTable.GetStringId(groupArgs[2])); break;

                case 4: new TagGroup(new Tag(groupArgs[0]), new Tag(groupArgs[1]), new Tag(groupArgs[2]), Cache.StringTable.GetStringId(groupArgs[3])); break;

                default: return(false);
                }

                goto begin;
            }

            CachedTag instance = null;

            TagGroup.Instances.TryGetValue(groupTag, out var tagGroup);

            using (var stream = Cache.OpenCacheReadWrite())
            {
                if (args.Count == 2)
                {
                    var tagIndex = -1;

                    if (!Cache.TryGetCachedTag(args[1], out instance))
                    {
                        if (args[1].StartsWith("0x"))
                        {
                            tagIndex = Convert.ToInt32(args[1], 16);
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        tagIndex = instance.Index;
                    }

                    while (tagIndex >= Cache.TagCache.Count)
                    {
                        Cache.TagCache.AllocateTag(TagGroup.None);
                    }

                    if (tagIndex < Cache.TagCache.Count)
                    {
                        if (Cache.TagCacheGenHO.Tags[tagIndex] != null)
                        {
                            var oldInstance = Cache.TagCacheGenHO.Tags[tagIndex];
                            Cache.TagCacheGenHO.Tags[tagIndex] = null;
                            Cache.TagCacheGenHO.SetTagDataRaw(stream, oldInstance, new byte[] { });
                        }

                        instance = Cache.TagCache.CreateCachedTag(tagIndex, TagGroup.Instances[groupTag]);
                        Cache.TagCacheGenHO.Tags[tagIndex] = (CachedTagHaloOnline)instance;
                    }
                }

                if (instance == null)
                {
                    instance = Cache.TagCache.AllocateTag(TagGroup.Instances[groupTag]);
                }

                Cache.Serialize(stream, instance, Activator.CreateInstance(TagDefinition.Find(groupTag)));
            }

            var tagName = instance.Name ?? $"0x{instance.Index:X4}";

            Console.WriteLine($"[Index: 0x{instance.Index:X4}] {tagName}.{Cache.StringTable.GetString(instance.Group.Name)}");
            return(true);
        }
Ejemplo n.º 9
0
        public override object Execute(List <string> args)
        {
            if (args.Count < 2)
            {
                return(false);
            }
            var outputPath = args[0];

            // Load each file and do version detection
            var infos = new List <HaloOnlineCacheContext>();

            foreach (var path in args.Skip(1))
            {
                Console.WriteLine("Loading {0}...", path);

                // Load the cache file
                var cacheContext = new HaloOnlineCacheContext(new FileInfo(path).Directory);
                infos.Add(cacheContext);
            }

            var result = new TagVersionMap();

            using (var baseStream = CacheContext.OpenTagCacheRead())
            {
                // Get the scenario tags for this cache
                Console.WriteLine("Finding base scenario tags...");
                var baseScenarios = FindScenarios(CacheContext, baseStream);
                var baseVersion   = CacheContext.Version;
                var baseTagData   = new Dictionary <int, object>();
                foreach (var scenario in baseScenarios)
                {
                    baseTagData[scenario.Tag.Index] = scenario.Data;
                }

                // Now compare with each of the other caches
                foreach (var info in infos)
                {
                    using (var stream = info.OpenTagCacheRead())
                    {
                        Console.WriteLine("Finding scenario tags in {0}...", info.TagCacheFile.FullName);

                        // Get the scenario tags and connect them to the base tags
                        var scenarios     = FindScenarios(info, stream);
                        var tagsToCompare = new Queue <QueuedTag>();
                        for (var i = 0; i < scenarios.Count; i++)
                        {
                            tagsToCompare.Enqueue(scenarios[i]);
                            if (i < baseScenarios.Count)
                            {
                                result.Add(baseVersion, baseScenarios[i].Tag.Index, info.Version, scenarios[i].Tag.Index);
                            }
                        }

                        // Process each tag in the queue, enqueuing all of its dependencies as well
                        while (tagsToCompare.Count > 0)
                        {
                            // Get the tag and its data
                            var tag = tagsToCompare.Dequeue();
                            TagPrinter.PrintTagShort(tag.Tag);
                            var data = tag.Data;
                            if (data == null)
                            {
                                // No data yet - deserialize it
                                var context = new TagSerializationContext(stream, info, tag.Tag);
                                var type    = TagDefinition.Find(tag.Tag.Group.Tag);
                                data = info.Deserializer.Deserialize(context, type);
                            }

                            // Now get the data for the base tag
                            var baseTag = result.Translate(info.Version, tag.Tag.Index, baseVersion);
                            if (baseTag == -1 || CacheContext.TagCache.Index[baseTag].Group.Tag != tag.Tag.Group.Tag)
                            {
                                continue;
                            }
                            if (!baseTagData.TryGetValue(baseTag, out object baseData))
                            {
                                // No data yet - deserialize it
                                var context = new TagSerializationContext(baseStream, CacheContext, CacheContext.TagCache.Index[baseTag]);
                                var type    = TagDefinition.Find(tag.Tag.Group.Tag);
                                baseData             = CacheContext.Deserializer.Deserialize(context, type);
                                baseTagData[baseTag] = baseData;
                            }

                            // Compare the two blocks
                            CompareBlocks(baseData, baseVersion, data, info.Version, result, tagsToCompare);
                        }
                    }
                }
            }

            // Write out the CSV
            Console.WriteLine("Writing results...");
            using (var writer = new StreamWriter(File.Open(outputPath, FileMode.Create, FileAccess.Write)))
                result.WriteCsv(writer);

            Console.WriteLine("Done!");
            return(true);
        }
Ejemplo n.º 10
0
        public override object Execute(List <string> args)
        {
            if (args.Count != 2)
            {
                return(false);
            }

            var groupTagInput = args[0];
            var blamTagName   = args[1];
            var groupTag      = Tag.Null;

            if (TagDefinition.Exists(groupTagInput))
            {
                groupTag = new Tag(groupTagInput);
            }
            else
            {
                foreach (var tagGroup in BlamCache.IndexItems.ClassList)
                {
                    if (groupTagInput == BlamCache.Strings.GetItemByID(tagGroup.StringID))
                    {
                        var chars = new char[4] {
                            ' ', ' ', ' ', ' '
                        };

                        for (var i = 0; i < 4; i++)
                        {
                            chars[i] = tagGroup.ClassCode[i];
                        }

                        groupTag = new Tag(new string(chars));
                        break;
                    }
                }
            }

            CacheFile.IndexItem tag = null;

            foreach (var blamTag in BlamCache.IndexItems)
            {
                if ((blamTag.GroupTag == groupTag.ToString()) && (blamTagName == "*" || blamTag.Name == blamTagName))
                {
                    tag = blamTag;
                    break;
                }
            }

            if (tag == null)
            {
                throw new Exception();
            }

            var tagName = $"(0x{tag.ID:X8}) {tag.Name.Substring(tag.Name.LastIndexOf('\\') + 1)}";

            var tagType    = TagDefinition.Find(groupTag);
            var definition = (TagStructure)BlamCache.Deserializer.Deserialize(new CacheSerializationContext(ref BlamCache, tag), tagType);
            var structure  = definition.GetTagStructureInfo(BlamCache.Version);

            var oldContext = ContextStack.Context;

            var commandContext = new CommandContext(ContextStack.Context, string.Format("{0}.{1}", tagName, groupTagInput));

            commandContext.AddCommand(new ListFieldsCommand(BlamCache, structure, definition));
            commandContext.AddCommand(new EditBlockCommand(ContextStack, BlamCache, tag, definition));
            commandContext.AddCommand(new CopyBlockElementsCommand(ContextStack, BlamCache, tag, structure, definition));
            commandContext.AddCommand(new Editing.ExitToCommand(ContextStack));
            ContextStack.Push(commandContext);

            Console.WriteLine($"Tag {tagName}.{groupTagInput} has been opened for editing.");
            Console.WriteLine("New commands are now available. Enter \"help\" to view them.");
            Console.WriteLine("Use \"exit\" to return to {0}.", oldContext.Name);

            return(true);
        }
Ejemplo n.º 11
0
        public static CommandContext Create(CommandContextStack contextStack, HaloOnlineCacheContext cacheContext, CachedTagInstance tag, object definition)
        {
            var documentationPath = $"{new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName}\\TagTool.xml";

            if (Documentation.ChildNodes.Count == 0 && File.Exists(documentationPath))
            {
                Documentation.Load(documentationPath);
            }

            var groupName = cacheContext.GetString(tag.Group.Name);
            var tagName   = tag?.Name ?? $"0x{tag.Index:X4}";

            var commandContext = new CommandContext(contextStack.Context, string.Format("{0}.{1}", tagName, groupName));

            switch (tag.Group.Tag.ToString())
            {
            case "bink":
                VideoContextFactory.Populate(commandContext, cacheContext, tag, (Bink)definition);
                break;

            case "bitm":     // bitmap
                BitmapContextFactory.Populate(commandContext, cacheContext, tag, (Bitmap)definition);
                break;

            case "coll":
                CollisionModelContextFactory.Populate(commandContext, cacheContext, tag, (CollisionModel)definition);
                break;

            case "hlmt":     // model
                ModelContextFactory.Populate(commandContext, cacheContext, tag, (Model)definition);
                break;

            case "jmad":
                AnimationContextFactory.Populate(commandContext, cacheContext, tag, (ModelAnimationGraph)definition);
                break;

            case "Lbsp":
                LightmapContextFactory.Populate(commandContext, cacheContext, tag, (ScenarioLightmapBspData)definition);
                break;

            case "mode":     // render_model
                RenderModelContextFactory.Populate(commandContext, cacheContext, tag, (RenderModel)definition);
                break;

            case "pmdf":
                ParticleModelContextFactory.Populate(commandContext, cacheContext, tag, (ParticleModel)definition);
                break;

            case "rm  ":     // render_method
            case "rmsh":     // shader
            case "rmd ":     // shader_decal
            case "rmfl":     // shader_foliage
            case "rmhg":     // shader_halogram
            case "rmss":     // shader_screen
            case "rmtr":     // shader_terrain
            case "rmw ":     // shader_water
            case "rmzo":     // shader_zonly
            case "rmcs":     // shader_custom
                RenderMethodContextFactory.Populate(commandContext, cacheContext, tag, (RenderMethod)definition);
                break;

            case "sbsp":
                BSPContextFactory.Populate(commandContext, cacheContext, tag, (ScenarioStructureBsp)definition);
                break;

            case "scnr":
                ScnrContextFactory.Populate(commandContext, cacheContext, tag, (Scenario)definition);
                break;

            case "snd!":
                SoundContextFactory.Populate(commandContext, cacheContext, tag, (Sound)definition);
                break;

            case "unic":     // multilingual_unicode_string_list
                UnicodeContextFactory.Populate(commandContext, cacheContext, tag, (MultilingualUnicodeStringList)definition);
                break;

            case "vfsl":     // vfiles_list
                VFilesContextFactory.Populate(commandContext, cacheContext, tag, (VFilesList)definition);
                break;

            case "pixl":
                Shaders.ShaderContextFactory <PixelShader> .Populate(commandContext, cacheContext, tag, (PixelShader)definition);

                break;

            case "vtsh":
                Shaders.ShaderContextFactory <VertexShader> .Populate(commandContext, cacheContext, tag, (VertexShader)definition);

                break;

            case "glps":
                Shaders.ShaderContextFactory <GlobalPixelShader> .Populate(commandContext, cacheContext, tag, (GlobalPixelShader)definition);

                break;

            case "glvs":
                Shaders.ShaderContextFactory <GlobalVertexShader> .Populate(commandContext, cacheContext, tag, (GlobalVertexShader)definition);

                break;

            case "rmt2":
                Shaders.RenderMethodTemplateContextFactory.Populate(commandContext, cacheContext, tag, (RenderMethodTemplate)definition);
                break;
            }

            var structure = TagStructure.GetTagStructureInfo(TagDefinition.Find(tag.Group.Tag), cacheContext.Version);

            commandContext.AddCommand(new ListFieldsCommand(cacheContext, structure, definition));
            commandContext.AddCommand(new SetFieldCommand(contextStack, cacheContext, tag, structure, definition));
            commandContext.AddCommand(new EditBlockCommand(contextStack, cacheContext, tag, definition));
            commandContext.AddCommand(new AddBlockElementsCommand(contextStack, cacheContext, tag, structure, definition));
            commandContext.AddCommand(new RemoveBlockElementsCommand(contextStack, cacheContext, tag, structure, definition));
            commandContext.AddCommand(new CopyBlockElementsCommand(contextStack, cacheContext, tag, structure, definition));
            commandContext.AddCommand(new PasteBlockElementsCommand(contextStack, cacheContext, tag, structure, definition));
            commandContext.AddCommand(new ForEachCommand(contextStack, cacheContext, tag, structure, definition));
            commandContext.AddCommand(new SaveTagChangesCommand(cacheContext, tag, definition));
            commandContext.AddCommand(new PokeTagChangesCommand(cacheContext, tag, definition));
            commandContext.AddCommand(new ExitToCommand(contextStack));

            return(commandContext);
        }
Ejemplo n.º 12
0
        private object GetTagDefinition(Stream stream, CachedTagInstance tag)
        {
            object definition = null;

            if (!LoadedDefinitions.ContainsKey(tag.Index))
            {
                var context = new TagSerializationContext(stream, CacheContext, tag);
                definition = LoadedDefinitions[tag.Index] = CacheContext.Deserializer.Deserialize(context, TagDefinition.Find(tag.Group.Tag));
            }
            else
            {
                definition = LoadedDefinitions[tag.Index];
            }

            return(definition);
        }
Ejemplo n.º 13
0
        private CachedTag ConvertCachedTagInstance(ModPackage modPack, CachedTag modTag)
        {
            Console.WriteLine($"Converting {modTag.Name}.{modTag.Group}...");

            // tag has already been converted
            if (TagMapping.ContainsKey(modTag.Index))
            {
                return(CacheContext.TagCache.GetTag(TagMapping[modTag.Index]));   // get the matching tag in the destination package
            }
            // Determine if tag requires conversion
            if (modTag.DefinitionOffset == ((CachedTagHaloOnline)modTag).TotalSize)
            {
                //modtag references a base tag, figure out which one is it and add it to the mapping
                CachedTag baseTag = null;
                if (modTag.Index < CacheContext.TagCache.Count)
                {
                    baseTag = CacheContext.TagCache.GetTag(modTag.Index);
                }

                // mod tag has a name, first check if baseTag name is null, else if the names don't match or group don't match
                if (baseTag != null && baseTag.Group == modTag.Group && baseTag.Name != null && baseTag.Name == modTag.Name)
                {
                    TagMapping[modTag.Index] = baseTag.Index;
                    return(baseTag);
                }
                else
                {
                    // tag name/group doesn't match base tag, try to look for it

                    CachedTag cacheTag;
                    if (CacheTagsByName.TryGetValue($"{modTag.Name}.{modTag.Group}", out cacheTag))
                    {
                        TagMapping[modTag.Index] = cacheTag.Index;
                        return(cacheTag);
                    }

                    // Failed to find tag in base cache
                    Console.Error.WriteLine($"Failed to find {modTag.Name}.{modTag.Group.ToString()} in the base cache, returning null tag reference.");
                    //return null;
                    throw new Exception("Failed to find tag when applying.");
                }
            }
            else
            {
                CachedTag newTag;
                if (!CacheTagsByName.TryGetValue($"{modTag.Name}.{modTag.Group}", out newTag))
                {
                    newTag      = CacheContext.TagCache.AllocateTag(modTag.Group);
                    newTag.Name = modTag.Name;
                }

                TagMapping.Add(modTag.Index, newTag.Index);
                var definitionType = TagDefinition.Find(modTag.Group.Tag);
                var deserializer   = new TagDeserializer(CacheVersion.HaloOnline106708);
                var tagDefinition  = deserializer.Deserialize(new ModPackageTagSerializationContext(modPack.TagCachesStreams[0], CacheContext, modPack, (CachedTagHaloOnline)modTag), definitionType);
                tagDefinition = ConvertData(modPack, tagDefinition);

                if (definitionType == typeof(ForgeGlobalsDefinition))
                {
                    tagDefinition = ConvertForgeGlobals((ForgeGlobalsDefinition)tagDefinition);
                }
                else if (definitionType == typeof(Scenario))
                {
                    tagDefinition = ConvertScenario(modPack, (Scenario)tagDefinition);
                }
                CacheContext.Serialize(CacheStream, newTag, tagDefinition);

                foreach (var resourcePointer in ((CachedTagHaloOnline)modTag).ResourcePointerOffsets)
                {
                    var newTagHo = newTag as CachedTagHaloOnline;
                    newTagHo.AddResourceOffset(resourcePointer);
                }
                return(newTag);
            }
        }
Ejemplo n.º 14
0
        public void LoadTagEditor(CachedTagInstance tag)
        {
            if (tag == null || (CurrentTag != null && CurrentTag.Index == tag.Index))
            {
                return;
            }

            LoadingTag = true;

            object definition = null;

            if (CurrentTags.ContainsKey(tag.Index))
            {
                definition = CurrentTags[tag.Index];
            }

            tagTreeView.Enabled = false;

            tagEditorPanel.Controls.Clear();

            var tagName = tag.Name ?? $"0x{tag.Index:X4}";

            var groupName = CacheContext.GetString(tag.Group.Name);

            statusLabel.Text = $"Loading {tagName}.{ groupName}...";

            progressBar.Style = ProgressBarStyle.Marquee;
            progressBar.MarqueeAnimationSpeed = 30;

            if (definition == null)
            {
                using (var stream = CacheContext.OpenTagCacheRead())
                    definition = CacheContext.Deserializer.Deserialize(
                        new TagSerializationContext(stream, CacheContext, tag),
                        TagDefinition.Find(tag.Group.Tag));
            }

            if (tagName.Contains("\\"))
            {
                var index = tagName.LastIndexOf('\\') + 1;
                tagName = tagName.Substring(index, tagName.Length - index);
            }

            statusLabel.Text = $"Generating {groupName} interface...";
            Application.DoEvents();

            var point = new Point();

            if (tag.IsInGroup("matg") || tag.IsInGroup("mulg") || tag.IsInGroup("scnr") || tag.IsInGroup("sbsp"))
            {
                var control = new StructMultiControl(this, CacheContext, tag, definition)
                {
                    Dock = DockStyle.Fill
                };

                control.GetFieldValue(null, definition, definition);

                tagEditorPanel.Controls.Add(control);
            }
            else if (tag.IsInGroup("bitm") || tag.IsInGroup("obje"))
            {
                var splitContainer = new SplitContainer
                {
                    Dock        = DockStyle.Fill,
                    Orientation = Orientation.Horizontal
                };

                splitContainer.FixedPanel = FixedPanel.Panel1;

                tagEditorPanel.Controls.Add(splitContainer);
                splitContainer.BringToFront();

                if (tag.IsInGroup("bitm"))
                {
                    splitContainer.SplitterDistance = Math.Min((short)512, Math.Max((short)16, ((TagTool.Tags.Definitions.Bitmap)definition).Images[0].Height));
                }
                else if (tag.IsInGroup("obje"))
                {
                    splitContainer.SplitterDistance = 384;
                }

                if (tag.IsInGroup("bitm"))
                {
                    var bitmDefinition = (TagTool.Tags.Definitions.Bitmap)definition;

                    var bitmapControl = new BitmapControl(CacheContext, bitmDefinition)
                    {
                        Dock = DockStyle.Fill
                    };

                    splitContainer.Panel1.Controls.Add(bitmapControl);
                    bitmapControl.BringToFront();
                }
                else if (tag.IsInGroup("obje"))
                {
                    var modelControl = new ObjectControl(CacheContext, (GameObject)definition)
                    {
                        Dock = DockStyle.Fill
                    };

                    splitContainer.Panel1.Controls.Add(modelControl);
                    modelControl.BringToFront();
                }

                var control = tag.IsInGroup("obje") ?
                              (Control) new StructMultiControl(this, CacheContext, tag, definition)
                {
                    Dock = DockStyle.Fill
                } :
                new StructControl(this, CacheContext, definition.GetType(), null);

                ((IFieldControl)control).GetFieldValue(null, definition, definition);
                control.Location = point;

                splitContainer.Panel2.Controls.Add(control);
                splitContainer.Panel2.AutoScroll = true;
            }
            else
            {
                if (tag.IsInGroup("snd!"))
                {
                    var soundControl = new SoundControl(CacheContext, tag, (TagTool.Tags.Definitions.Sound)definition)
                    {
                        Dock = DockStyle.Top
                    };

                    tagEditorPanel.Controls.Add(soundControl);
                    soundControl.BringToFront();

                    point.Y = soundControl.Bottom;
                }

                var control = new StructControl(this, CacheContext, definition.GetType(), null);
                control.GetFieldValue(null, definition, definition);

                control.Location = point;

                tagEditorPanel.Controls.Add(control);
            }

            statusLabel.Text = "";

            progressBar.Style = ProgressBarStyle.Continuous;
            progressBar.MarqueeAnimationSpeed = 0;

            tagTreeView.Enabled = true;
            CurrentTag          = tag;

            if (!CurrentTags.ContainsKey(tag.Index))
            {
                CurrentTags[tag.Index] = definition;

                var item = new TagInstanceItem {
                    CacheContext = CacheContext, Tag = tag
                };
                currentTagsComboBox.Items.Add(item);

                currentTagsComboBox.SelectedItem = item;
            }
            else
            {
                for (var i = 0; i < currentTagsComboBox.Items.Count; i++)
                {
                    var item = (TagInstanceItem)currentTagsComboBox.Items[i];

                    if (item.Tag.Index == tag.Index)
                    {
                        currentTagsComboBox.SelectedIndex = i;
                        break;
                    }
                }
            }

            LoadingTag = false;
        }
Ejemplo n.º 15
0
 public CachedTagInstance[] GetShaderInstances(Type template_type)
 {
     CachedTagInstance[] shader_instances = null;
     if (template_type != null)
     {
         shader_instances = CacheContext.TagCache.Index.Where(instance => instance != null && TagDefinition.Find(instance.Group.Tag) == template_type).ToArray();
     }
     else
     {
         shader_instances = CacheContext.TagCache.Index.Where(instance => instance != null && SupportedShaderTypes.Contains(TagDefinition.Find(instance.Group.Tag))).ToArray();
     }
     return(shader_instances);
 }
Ejemplo n.º 16
0
 public override object Deserialize(Stream stream, CachedTag instance) =>
 Deserialize(new Gen1SerializationContext(stream, this, (CachedTagGen1)instance), TagDefinition.Find(instance.Group.Tag));
Ejemplo n.º 17
0
 public object Deserialize(Stream stream, CachedTagGen2 instance) =>
 Deserialize(new Gen2SerializationContext(stream, this, instance), TagDefinition.Find(instance.Group.Tag));
Ejemplo n.º 18
0
        public override object Execute(List <string> args)
        {
            if (args.Count > 1)
            {
                return(false);
            }

            Process process;

            if (args.Count == 1)
            {
                if (!int.TryParse(args[0], NumberStyles.HexNumber, null, out int processId) || processId < 0)
                {
                    return(false);
                }

            #if !DEBUG
                try
                {
            #endif
                process = Process.GetProcessById(processId);
            #if !DEBUG
            }
            catch (ArgumentException)
            {
                Console.Error.WriteLine("Unable to find a process with an ID of 0x{0:X}", processId);
                return(true);
            }
            #endif
            }
            else
            {
                var processes = Process.GetProcessesByName("eldorado");

                if (processes.Length == 0)
                {
                    Console.Error.WriteLine("Unable to find any eldorado.exe processes.");
                    return(true);
                }

                process = processes[0];
            }

            using (var processStream = new ProcessMemoryStream(process))
            {
                var address = GetTagAddress(processStream, Tag.Index);

                var runtimeContext = new RuntimeSerializationContext(CacheContext, processStream);
                processStream.Position = address + Tag.DefinitionOffset;

                var definition = CacheContext.Deserializer.Deserialize(runtimeContext, TagDefinition.Find(Tag.Group.Tag));
                CacheContext.Serializer.Serialize(runtimeContext, Value);

                if (address != 0)
                {
                    Console.WriteLine("Tag 0x{0:X} is loaded at 0x{1:X8} in process 0x{2:X}.", Tag.Index, address, process.Id);
                }
                else
                {
                    Console.Error.WriteLine("Tag 0x{0:X} is not loaded in process 0x{1:X}.", Tag.Index, process.Id);
                }
            }

            return(true);
        }