Beispiel #1
0
        private dynamic ReadDefinition(BinaryReader reader)
        {
            switch (type)
            {
            case field_type._field_block:
                return(reader.ReadFieldDefinition <TagBlockDefinition>(this));

            case field_type._field_struct:
                return(reader.ReadFieldDefinition <tag_struct_definition>(this));

            case field_type._field_char_enum:
            case field_type._field_enum:
            case field_type._field_long_enum:
            case field_type._field_byte_flags:
            case field_type._field_word_flags:
            case field_type._field_long_flags:
                return(reader.ReadFieldDefinition <enum_definition>(this));

            case field_type._field_tag_reference:
                return(reader.ReadFieldDefinition <tag_reference_definition>(this));

            case field_type._field_data:
                return(reader.ReadFieldDefinition <tag_data_definition>(this));

            case field_type._field_explanation:
            {
                var value = Guerilla.ReadString(reader, definition);
                return(value);
            }

            default:
                return(definition);
            }
        }
        public void Read(IntPtr h2LangLib, BinaryReader reader)
        {
            // Read all the fields from the stream.
            this.type         = (field_type)reader.ReadInt16();
            this.padding      = reader.ReadInt16();
            this.name_address = reader.ReadInt32();
            this.definition   = reader.ReadInt32();
            this.group_tag    = reader.ReadInt32();

            // Read Properties
            this.Name       = Guerilla.ReadString(reader, this.name_address);
            this.Definition = ReadDefinition(reader);
        }
Beispiel #3
0
        public tag_field_set(BinaryReader reader, Action <BinaryReader, IList <tag_field> > postprocessFunction = null)
            : this()
        {
            version              = reader.ReadFieldDefinition <s_tag_field_set_version>();
            size                 = reader.ReadInt32();
            alignment_bit        = reader.ReadInt32();
            parent_version_index = reader.ReadInt32();
            fields_address       = reader.ReadInt32();
            size_string_address  = reader.ReadInt32();

            // Read the size_of string.
            size_string = Guerilla.ReadString(reader, size_string_address);

            ReadFields(reader, postprocessFunction);
        }
Beispiel #4
0
        public tag_struct_definition(BinaryReader reader)
            : this()
        {
            // Read all the fields from the stream.
            name_address             = reader.ReadInt32();
            group_tag                = reader.ReadInt32();
            display_name_address     = reader.ReadInt32();
            block_definition_address = reader.ReadInt32();

            displayName = Guerilla.ReadString(reader, display_name_address);
            name        = Guerilla.ReadString(reader, name_address);

            reader.BaseStream.Seek(block_definition_address, SeekOrigin.Begin);
            Definition = reader.ReadFieldDefinition <TagBlockDefinition>();
        }
Beispiel #5
0
        public void Read(BinaryReader reader)
        {
            // Read all the fields from the stream.
            nameAddress              = reader.ReadInt32();
            flags                    = reader.ReadInt32();
            alignmentBit             = reader.ReadInt32();
            maximumSize              = reader.ReadInt32();
            maximumSizeStringAddress = reader.ReadInt32();
            byteswapFunction         = reader.ReadInt32();
            copyFunction             = reader.ReadInt32();

            // Read the strings.
            name = Guerilla.ReadString(reader, nameAddress);
            maximum_size_string = Guerilla.ReadString(reader, maximumSizeStringAddress);
        }
        public void Read(IntPtr h2LangLib, BinaryReader reader)
        {
            // Read all the fields from the stream.
            this.nameAddress              = reader.ReadInt32();
            this.flags                    = reader.ReadInt32();
            this.alignmentBit             = reader.ReadInt32();
            this.maximumSize              = reader.ReadInt32();
            this.maximumSizeStringAddress = reader.ReadInt32();
            this.byteswapFunction         = reader.ReadInt32();
            this.copyFunction             = reader.ReadInt32();

            // Read the strings.
            this.name = Guerilla.ReadString(reader, this.nameAddress);
            this.maximum_size_string = Guerilla.ReadString(reader, this.maximumSizeStringAddress);
        }
Beispiel #7
0
        public void Read(BinaryReader reader)
        {
            // Read all the fields from the stream.
            type = (field_type)reader.ReadInt16();
            if (type == field_type._field_rgb_color)
            {
            }
            padding      = reader.ReadInt16();
            name_address = reader.ReadInt32();
            definition   = reader.ReadInt32();
            group_tag    = reader.ReadInt32();

            // Read Properties
            Name       = Guerilla.ReadString(reader, name_address);
            Definition = ReadDefinition(reader);
        }
        public tag_group(BinaryReader reader)
            : this()
        {
            var stream = reader.BaseStream;

            this.name_address     = reader.ReadInt32();
            this.flags            = reader.ReadInt32();
            this.group_tag        = reader.ReadInt32();
            this.parent_group_tag = reader.ReadInt32();
            this.version          = reader.ReadInt16();
            this.initialized      = reader.ReadByte();

            stream.Seek(1, SeekOrigin.Current);

            this.postprocess_proc          = reader.ReadInt32();
            this.save_postprocess_proc     = reader.ReadInt32();
            this.postprocess_for_sync_proc = reader.ReadInt32();

            stream.Seek(4, SeekOrigin.Current);

            this.definition_address = reader.ReadInt32();
            this.child_group_tags   = new int[16];
            for (int i = 0; i < 16; i++)
            {
                this.child_group_tags[i] = reader.ReadInt32();
            }
            this.childs_count = reader.ReadInt16();

            stream.Seek(2, SeekOrigin.Current);

            this.default_tag_path_address = reader.ReadInt32();


            this.text = Guerilla.ReadString(reader, this.name_address);

            DefaultPath = Guerilla.ReadString(reader, this.default_tag_path_address);
            stream.Seek(this.definition_address, SeekOrigin.Begin);
            if (Class.ToString() == "snd!")
            {
                Definition = reader.ReadFieldDefinition <TagBlockDefinition>();
            }
            else
            {
                Definition = reader.ReadFieldDefinition <TagBlockDefinition>();
            }
        }
Beispiel #9
0
        public void Read(BinaryReader reader)
        {
            // Read all the fields from the stream.
            option_count    = reader.ReadInt32();
            options_address = reader.ReadInt32();
            flags           = reader.ReadInt32();

            Options = new List <string>(option_count);
            for (var i = 0; i < option_count; ++i)
            {
                // Seek to the next option name address.
                reader.BaseStream.Position = options_address + (i * 4);

                // Read the string from the stream.
                int string_address = reader.ReadInt32();
                var option         = Guerilla.ReadString(reader, string_address);
                Options.Add(option);
            }
        }
Beispiel #10
0
        private void Read(BinaryReader reader)
        {
            var stream = reader.BaseStream;

            nameAddress    = reader.ReadInt32();
            flags          = reader.ReadInt32();
            groupTag       = reader.ReadInt32();
            parentGroupTag = reader.ReadInt32();
            version        = reader.ReadInt16();
            initialized    = reader.ReadByte();

            stream.Seek(1, SeekOrigin.Current);

            postprocessProc        = reader.ReadInt32();
            savePostprocessProc    = reader.ReadInt32();
            postprocessForSyncProc = reader.ReadInt32();

            stream.Seek(4, SeekOrigin.Current);

            definitionAddress = reader.ReadInt32();
            childGroupTags    = new int[16];
            for (var i = 0; i < 16; i++)
            {
                childGroupTags[i] = reader.ReadInt32();
            }
            childsCount = reader.ReadInt16();

            stream.Seek(2, SeekOrigin.Current);

            defaultTagPathAddress = reader.ReadInt32();


            Name = Guerilla.ReadString(reader, nameAddress);

            DefaultPath = Guerilla.ReadString(reader, defaultTagPathAddress);
            stream.Seek(definitionAddress, SeekOrigin.Begin);
            Definition = reader.ReadFieldDefinition <TagBlockDefinition>();
        }
Beispiel #11
0
        public TagBlockDefinition(BinaryReader reader)
            : this()
        {
            // Read all the fields from the stream.
            display_name_address = reader.ReadInt32();
            name_address         = reader.ReadInt32();
            flags = reader.ReadInt32();
            maximum_element_count = reader.ReadInt32();
            maximum_element_count_string_address = reader.ReadInt32();
            field_sets_address          = reader.ReadInt32();
            field_set_count             = reader.ReadInt32();
            field_set_latest_address    = reader.ReadInt32();
            reader.BaseStream.Position += 4;
            postprocess_proc            = reader.ReadInt32();
            format_proc           = reader.ReadInt32();
            generate_default_proc = reader.ReadInt32();
            dispose_element_proc  = reader.ReadInt32();

            // Read the display name and name strings.
            display_name = Guerilla.ReadString(reader, display_name_address);
            name         = Guerilla.ReadString(reader, name_address);
            maximum_element_count_str = Guerilla.ReadString(reader, maximum_element_count_string_address);
            if (name == "sound_block")
            {
                field_sets_address       = 0x957870;
                field_set_latest_address = 0x906178;

                FieldSets = new List <tag_field_set>(1);
                var fieldSet = new tag_field_set
                {
                    version              = { fields_address = 0x906178, index = 0, upgrade_proc = 0, size_of = -1 },
                    size                 = 172,
                    alignment_bit        = 0,
                    parent_version_index = -1,
                    fields_address       = 0x906178,
                    size_string_address  = 0x00795330,
                    size_string          = "sizeof(sound_definition)"
                };


                var definitionName = name;
                fieldSet.ReadFields(reader,
                                    Guerilla.PostprocessFunctions.Where(x => x.Key == definitionName)
                                    .Select(x => x.Value)
                                    .FirstOrDefault());
                LatestFieldSet = fieldSet;
                FieldSets.Add(fieldSet);
            }
            else
            {
                FieldSets = new List <tag_field_set>(field_set_count);
                var definitionName = name;
                var address        = field_sets_address;
                for (var i = 0; i < field_set_count; ++i)
                {
                    reader.BaseStream.Seek(address, SeekOrigin.Begin);
                    var fieldSet = new tag_field_set(reader);
                    FieldSets.Add(fieldSet);
                    address += tag_field_set.Size;
                }
                switch (name)
                {
                case "materials_block":
                    LatestFieldSet = FieldSets[0];
                    if (LatestFieldSet.Fields.Count == 5)
                    {
                        name           = "phmo_materials_block";
                        definitionName = "phmo_materials_block";
                    }
                    break;

                case "hud_globals_block":
                    LatestFieldSet = FieldSets[0];
                    break;

                case "global_new_hud_globals_struct_block":
                    LatestFieldSet = FieldSets[0];
                    break;

                case "sound_promotion_parameters_struct_block":
                    LatestFieldSet = FieldSets[0];
                    break;

                case "animation_pool_block":
                    LatestFieldSet = FieldSets[4];
                    break;

                case "sound_gestalt_promotions_block":
                    LatestFieldSet = FieldSets[0];
                    break;

                case "sound_block":
                    LatestFieldSet = FieldSets[0];
                    break;

                case "tag_block_index_struct_block":
                    LatestFieldSet = FieldSets[0];
                    break;

                case "vertex_shader_classification_block":
                    LatestFieldSet = FieldSets[0];
                    break;

                default:
                    reader.BaseStream.Seek(field_set_latest_address, SeekOrigin.Begin);
                    var latestFieldSet = new tag_field_set(reader,
                                                           Guerilla.PostprocessFunctions.Where(x => x.Key == definitionName)
                                                           .Select(x => x.Value)
                                                           .FirstOrDefault());
                    LatestFieldSet = latestFieldSet;
                    break;
                }
            }
        }
Beispiel #12
0
        public TagBlockDefinition(BinaryReader reader)
            : this()
        {
            // Read all the fields from the stream.
            this.display_name_address = reader.ReadInt32();
            this.name_address         = reader.ReadInt32();
            this.flags = reader.ReadInt32();
            this.maximum_element_count = reader.ReadInt32();
            this.maximum_element_count_string_address = reader.ReadInt32();
            this.field_sets_address       = reader.ReadInt32();
            this.field_set_count          = reader.ReadInt32();
            this.field_set_latest_address = reader.ReadInt32();
            reader.BaseStream.Position   += 4;
            this.postprocess_proc         = reader.ReadInt32();
            this.format_proc           = reader.ReadInt32();
            this.generate_default_proc = reader.ReadInt32();
            this.dispose_element_proc  = reader.ReadInt32();

            // Read the display name and name strings.
            this.display_name = Guerilla.ReadString(reader, this.display_name_address);
            this.name         = Guerilla.ReadString(reader, this.name_address);
            this.maximum_element_count_str = Guerilla.ReadString(reader, this.maximum_element_count_string_address);
            if (name == "sound_block")
            {
                this.field_sets_address = 0x957870;

                FieldSets = new List <tag_field_set>(1);
                var fieldSet = new tag_field_set();

                //definition.field_set_latest_address = 0x906178;
                fieldSet.version.fields_address = 0x906178;
                fieldSet.version.index          = 0;
                fieldSet.version.upgrade_proc   = 0;
                fieldSet.version.size_of        = -1;
                fieldSet.size                 = 172;
                fieldSet.alignment_bit        = 0;
                fieldSet.parent_version_index = -1;
                fieldSet.fields_address       = 0x906178;
                fieldSet.size_string_address  = 0x00795330;
                fieldSet.size_string          = "sizeof(sound_definition)";

                var definitionName = this.name;
                fieldSet.ReadFields(reader, Guerilla.PostprocessFunctions.Where(x => x.Key == definitionName).Select(x => x.Value).FirstOrDefault());
                LatestFieldSet = fieldSet;
                FieldSets.Add(fieldSet);
            }
            else
            {
                FieldSets = new List <tag_field_set>(field_set_count);
                var definitionName = this.name;
                var address        = field_sets_address;
                for (var i = 0; i < field_set_count; ++i)
                {
                    reader.BaseStream.Seek(address, SeekOrigin.Begin);
                    var fieldSet = new tag_field_set(reader);
                    FieldSets.Add(fieldSet);
                    address += tag_field_set.Size;
                }
                if (this.name == "sound_promotion_parameters_struct_block")
                {
                    LatestFieldSet = FieldSets[0];
                }
                else
                {
                    reader.BaseStream.Seek(this.field_set_latest_address, SeekOrigin.Begin);
                    var latestFieldSet = new tag_field_set(reader, Guerilla.PostprocessFunctions.Where(x => x.Key == definitionName).Select(x => x.Value).FirstOrDefault());
                    LatestFieldSet = latestFieldSet;
                }
            }
        }