private void LoadDataHalo5()
        {
            var tag = item as ModuleItem;

            Metadata.Clear();

            var doc = new XmlDocument();

            doc.Load(fileName);

            var offset = 0;

            using (var tagReader = tag.CreateReader())
            {
                var header = new MetadataHeader(tagReader);
                using (var reader = tagReader.CreateVirtualReader(header.Header.HeaderSize))
                {
                    var rootIndex = header.StructureDefinitions.First(s => s.Type == StructureType.Main).TargetIndex;
                    var mainBlock = header.DataBlocks[rootIndex];

                    foreach (XmlNode n in doc.DocumentElement.ChildNodes)
                    {
                        try
                        {
                            var def  = FieldDefinition.GetHalo5Definition(n);
                            var meta = MetaValueBase.GetMetaValue(n, tag, header, mainBlock, reader, mainBlock.Offset, offset);
                            Metadata.Add(meta);
                            offset += def.Size;
                        }
                        catch { break; }
                    }
                }
            }
        }
        private void LoadDataHalo3()
        {
            var tag = item as IIndexItem;

            Metadata.Clear();

            var doc = new XmlDocument();

            doc.Load(fileName);

            context?.DataSource?.Dispose();
            context = new Plugins.MetaViewer.Halo3.MetaContext(doc, tag.CacheFile, tag);

            foreach (XmlNode n in doc.DocumentElement.ChildNodes)
            {
                try
                {
                    var meta = MetaValueBase.GetMetaValue(n, context, tag.MetaPointer.Address);
                    Metadata.Add(meta);
                }
                catch { }
            }

            context.UpdateBlockIndices();
        }
        public override void UpdateFromMetaValue(MetaValueBase meta, string fieldId)
        {
            if (fieldId == FieldId.Name)
            {
                SetStringId(meta, ref name, nameof(Name));
                return;
            }
            if (fieldId == FieldId.NameIndex)
            {
                return;
            }

            var multi  = meta as MultiValue;
            var vector = new RealVector3D(multi.Value1, multi.Value2, multi.Value3);

            switch (fieldId)
            {
            case FieldId.ForwardVector:
                ForwardVector = vector;
                break;

            case FieldId.UpVector:
                UpVector = vector;
                break;

            case FieldId.Position:
                Position = vector;
                break;

            case FieldId.Size:
                Size = vector;
                break;
            }
        }
 public virtual void UpdateFromMetaValue(MetaValueBase meta, string fieldId)
 {
     if (fieldId == FieldId.Name)
     {
         Name = ((Plugins.MetaViewer.Halo3.StringValue)meta).Value;
     }
 }
 public override void UpdateFromMetaValue(MetaValueBase meta, string fieldId)
 {
     switch (fieldId)
     {
     case FieldId.Position:
         var multi = meta as MultiValue;
         Position = new RealVector3D(multi.Value1, multi.Value2, multi.Value3);
         break;
     }
 }
        protected void SetStringId(MetaValueBase meta, ref StringId stringId, string propertyName)
        {
            var editor   = meta as StringIdValue;
            var cache    = Parent.ScenarioTag.CacheFile;
            var intValue = cache.StringIndex.GetStringId(editor.Value);

            if (intValue >= 0 && stringId.Id != intValue)
            {
                stringId = new StringId(intValue, cache);
                RaisePropertyChanged(propertyName);
            }
        }
Exemple #7
0
        void IMetaUpdateReceiver.UpdateFromMetaValue(MetaValueBase meta, string fieldId)
        {
            var receiver = Tag as IMetaUpdateReceiver;

            if (receiver == null)
            {
                return;
            }

            receiver.UpdateFromMetaValue(meta, fieldId);

            if (fieldId == FieldId.Name || fieldId == FieldId.NameIndex || fieldId == FieldId.TagReference)
            {
                Content = receiver.GetDisplayName();
            }
        }
        public void Reload()
        {
            if (rootNode == null)
            {
                return;
            }

            foreach (var meta in valuesById.Values)
            {
                meta.PropertyChanged -= Meta_PropertyChanged;
            }
            Metadata.Clear();
            valuesById.Clear();

            //load altnodes beforehand so any root nodes will overwrite altnodes if they are duplicates
            //this brings in additional xml nodes to use their block names
            foreach (var t in altNodes)
            {
                if (t.Item1.Name.ToLower() == "section")
                {
                    new StructureValue(t.Item1, context, context.CreateReader(), t.Item2);
                }
                else
                {
                    MetaValueBase.GetMetaValue(t.Item1, context, t.Item2);
                }
            }

            foreach (XmlNode n in rootNode.ChildNodes)
            {
                try
                {
                    var meta = MetaValueBase.GetMetaValue(n, context, baseAddress);
                    Metadata.Add(meta);
                    if (n.Attributes["id"] != null)
                    {
                        valuesById.Add(n.Attributes["id"].Value, meta);
                        meta.PropertyChanged += Meta_PropertyChanged;
                    }
                }
                catch { }
            }

            context.UpdateBlockIndices();
        }
 public override void UpdateFromMetaValue(MetaValueBase meta, string fieldId)
 {
     switch (fieldId)
     {
     case FieldId.Position:
     case FieldId.Orientation:
         var multi = meta as MultiValue;
         if (fieldId == FieldId.Position)
         {
             Position = new RealVector3D(multi.Value1, multi.Value2, multi.Value3);
         }
         else
         {
             Orientation = new RealVector2D(multi.Value1, multi.Value2);
         }
         break;
     }
 }
Exemple #10
0
        public override void UpdateFromMetaValue(MetaValueBase meta, string fieldId)
        {
            switch (fieldId)
            {
            case FieldId.Position:
            case FieldId.Rotation:
                var multi  = meta as MultiValue;
                var vector = new RealVector3D(multi.Value1, multi.Value2, multi.Value3);
                if (fieldId == FieldId.Position)
                {
                    Position = vector;
                }
                else
                {
                    Rotation = vector;
                }
                break;

            case FieldId.QRotation:
                multi     = meta as MultiValue;
                QRotation = new RealVector4D(multi.Value1, multi.Value2, multi.Value3, multi.Value4);
                break;

            case FieldId.Scale:
                var simple = meta as SimpleValue;
                Scale = float.Parse(simple.Value.ToString());
                break;

            case FieldId.PaletteIndex:
                var blockIndex = meta as BlockIndexValue;
                PaletteIndex = short.Parse(blockIndex.Value.ToString());
                break;

            case FieldId.NameIndex:
                blockIndex = meta as BlockIndexValue;
                NameIndex  = short.Parse(blockIndex.Value.ToString());
                break;

            case FieldId.Variant:
                SetStringId(meta, ref variant, nameof(Variant));
                break;
            }
        }
        public override void UpdateFromMetaValue(MetaValueBase meta, string fieldId)
        {
            switch (fieldId)
            {
            case FieldId.Name:
                SetStringId(meta, ref name, nameof(Name));
                break;

            case FieldId.Position:
            case FieldId.Rotation:
                var multi  = meta as MultiValue;
                var vector = new RealVector3D(multi.Value1, multi.Value2, multi.Value3);
                if (fieldId == FieldId.Position)
                {
                    Position = vector;
                }
                else
                {
                    Rotation = vector;
                }
                break;
            }
        }
        private void Reload()
        {
            var palette      = scenario.Palettes[paletteKey];
            var blockRef     = palette.PaletteBlockRef;
            var blockAddress = blockRef.TagBlock.Pointer.Address;
            var tagRefNode   = palette.PaletteNode.SelectSingleNode($"*[@id='{FieldId.TagReference}']");
            var tagRefOffset = tagRefNode.GetIntAttribute("offset") ?? 0;

            Metadata.Clear();
            for (int i = 0; i < blockRef.TagBlock.Count; i++)
            {
                var baseAddress = blockAddress + blockRef.BlockSize * i + tagRefOffset;
                var meta        = (TagReferenceValue)MetaValueBase.GetMetaValue(tagRefNode, context, baseAddress);

                if ((meta.SelectedItem?.Context?.Id ?? 0) == 0)
                {
                    meta.SelectedClass = meta.ClassOptions.FirstOrDefault(ci => ci.Label.ToLower() == paletteKey) ?? meta.ClassOptions.FirstOrDefault();
                }

                meta.PropertyChanged += Meta_PropertyChanged;
                Metadata.Add(meta);
            }
        }
 public abstract void UpdateFromMetaValue(MetaValueBase meta, string fieldId);