internal override void WriteBody(EndianBinaryWriter writer, StringSet stringSet, BinaryFormat format)
        {
            writer.Write(StartIndex);
            writer.Write(Nodes.Count);
            stringSet.WriteString(writer, ExternalName);
            stringSet.WriteString(writer, Name);

            bool shouldWriteRotation = format == BinaryFormat.FT && Nodes.Any(x =>
                                                                              Math.Abs(x.Rotation.X) > 0 ||
                                                                              Math.Abs(x.Rotation.Y) > 0 ||
                                                                              Math.Abs(x.Rotation.Z) > 0);

            writer.ScheduleWriteOffsetIf(shouldWriteRotation, 4, AlignmentMode.Left, () =>
            {
                foreach (var bone in Nodes)
                {
                    bone.WriteOsgBlockInfo(writer, stringSet);
                }
            });

            if (writer.AddressSpace == AddressSpace.Int64)
            {
                writer.WriteNulls(4 * sizeof(ulong));
            }
            else
            {
                writer.WriteNulls(5 * sizeof(uint));
            }
        }
示例#2
0
 internal override void WriteBody(EndianBinaryWriter writer, StringSet stringSet)
 {
     writer.Write(StartIndex);
     writer.Write(Bones.Count);
     stringSet.WriteString(writer, ExternalName);
     stringSet.WriteString(writer, InternalName);
     writer.WriteNulls(writer.AddressSpace.GetByteSize());
     writer.WriteNulls(3 * sizeof(uint));
 }
 internal override void WriteBody(EndianBinaryWriter writer, StringSet stringSet, BinaryFormat format)
 {
     writer.AddStringToStringTable(Name);
     writer.Write(Nodes.Count);
     writer.ScheduleWriteOffset(16, AlignmentMode.Left, () =>
     {
         foreach (var bone in Nodes)
         {
             stringSet.WriteString(writer, bone.Name);
         }
     });
     writer.ScheduleWriteOffset(16, AlignmentMode.Left, () =>
     {
         foreach (var bone in Nodes)
         {
             writer.Write(bone.Transformation);
         }
     });
 }
示例#4
0
        internal void Write(EndianBinaryWriter writer, BinaryFormat format)
        {
            var stringSet = new StringSet(this);

            writer.ScheduleWriteOffset(16, AlignmentMode.Center, () =>
            {
                foreach (var bone in Bones)
                {
                    if (bone.IsEx)
                    {
                        bone.Id = stringSet.GetStringId(bone.Name);
                    }

                    writer.Write(bone.Id);
                }
            });
            writer.ScheduleWriteOffset(16, AlignmentMode.Center, () =>
            {
                foreach (var bone in Bones)
                {
                    writer.Write(bone.InverseBindPoseMatrix);
                }
            });
            writer.ScheduleWriteOffset(16, AlignmentMode.Center, () =>
            {
                foreach (var bone in Bones)
                {
                    writer.AddStringToStringTable(bone.Name);
                }

                writer.WriteNulls(writer.AddressSpace.GetByteSize());
            });
            writer.ScheduleWriteOffsetIf(stringSet.Strings.Count > 0 || Blocks.Count > 0, 16, AlignmentMode.Center, () =>
            {
                var osageNames = new List <string>(Blocks.Count / 2);
                var osageNodes = new List <OsageNode>(Blocks.Count / 2);
                var clothNames = new List <string>(Blocks.Count / 8);

                foreach (var block in Blocks)
                {
                    switch (block)
                    {
                    case OsageBlock osageBlock:
                        osageBlock.StartIndex = osageNodes.Count;
                        osageNodes.AddRange(osageBlock.Nodes);
                        osageNames.Add(osageBlock.ExternalName);
                        break;

                    case ClothBlock clothBlock:
                        clothNames.Add(clothBlock.Name);
                        break;
                    }
                }

                writer.Write(osageNames.Count);
                writer.Write(osageNodes.Count);

                writer.WriteNulls(sizeof(uint));

                writer.ScheduleWriteOffset(4, AlignmentMode.Left, () =>
                {
                    foreach (var osageNode in osageNodes)
                    {
                        osageNode.Write(writer, stringSet);
                    }

                    writer.WriteNulls(3 * sizeof(uint));
                });
                writer.ScheduleWriteOffset(16, AlignmentMode.Left, () =>
                {
                    foreach (string value in osageNames)
                    {
                        writer.AddStringToStringTable(value);
                    }

                    foreach (string value in clothNames)
                    {
                        writer.AddStringToStringTable(value);
                    }

                    writer.WriteNulls(writer.AddressSpace.GetByteSize());
                });
                writer.ScheduleWriteOffset(16, AlignmentMode.Left, () =>
                {
                    foreach (var block in Blocks)
                    {
                        writer.AddStringToStringTable(block.Signature);
                        writer.ScheduleWriteOffset(8, AlignmentMode.Left, () => block.Write(writer, stringSet, format));
                    }

                    writer.WriteNulls(writer.AddressSpace.GetByteSize() * 2);
                });
                writer.Write(stringSet.Strings.Count);
                writer.ScheduleWriteOffset(16, AlignmentMode.Left, () =>
                {
                    foreach (string value in stringSet.Strings)
                    {
                        writer.AddStringToStringTable(value);
                    }

                    writer.WriteNulls(writer.AddressSpace.GetByteSize());
                });
                writer.ScheduleWriteOffset(16, AlignmentMode.Left, () =>
                {
                    foreach (var osageNode in osageNodes)
                    {
                        if (string.IsNullOrEmpty(osageNode.SiblingName))
                        {
                            continue;
                        }

                        stringSet.WriteString(writer, osageNode.Name);
                        stringSet.WriteString(writer, osageNode.SiblingName);
                        writer.Write(osageNode.SiblingMaxDistance);
                    }

                    writer.WriteNulls(3 * sizeof(uint));
                });
                writer.Write(clothNames.Count);

                if (writer.AddressSpace == AddressSpace.Int64)
                {
                    writer.WriteNulls(4);
                }

                writer.WriteNulls(7 * writer.AddressSpace.GetByteSize());
            });
            writer.Write(Bones.Count);
            writer.ScheduleWriteOffsetIf(Bones.Any(x => x.Parent != null), 16, AlignmentMode.Center, () =>
            {
                foreach (var bone in Bones)
                {
                    writer.Write(bone.Parent?.Id ?? 0xFFFFFFFF);
                }
            });
            writer.WriteNulls(3 * writer.AddressSpace.GetByteSize());
        }