// Pre-UE4.23 code
        public void SerializeBuffersLegacy(FAssetArchive Ar, FStripDataFlags stripDataFlags)
        {
            PositionVertexBuffer = new FPositionVertexBuffer(Ar);
            VertexBuffer         = new FStaticMeshVertexBuffer(Ar);

            if (Ar.Game == EGame.GAME_BORDERLANDS3)
            {
                var numColorStreams = Ar.Read <int>();
                ColorVertexBuffer = new FColorVertexBuffer(Ar);
                for (var i = 0; i < numColorStreams - 1; i++)
                {
                    var _ = new FColorVertexBuffer(Ar);
                }
            }
            else
            {
                ColorVertexBuffer = new FColorVertexBuffer(Ar);
            }

            IndexBuffer = new FRawStaticIndexBuffer(Ar);

            if (Ar.Ver >= UE4Version.VER_UE4_SOUND_CONCURRENCY_PACKAGE && !stripDataFlags.IsClassDataStripped((byte)EClassDataStripFlag.CDSF_ReversedIndexBuffer))
            {
                ReversedIndexBuffer          = new FRawStaticIndexBuffer(Ar);
                DepthOnlyIndexBuffer         = new FRawStaticIndexBuffer(Ar);
                ReversedDepthOnlyIndexBuffer = new FRawStaticIndexBuffer(Ar);
            }
            else
            {
                // UE4.8 or older, or when has CDSF_ReversedIndexBuffer
                DepthOnlyIndexBuffer = new FRawStaticIndexBuffer(Ar);
            }

            if (Ar.Ver is >= UE4Version.VER_UE4_FTEXT_HISTORY and < UE4Version.VER_UE4_RENAME_CROUCHMOVESCHARACTERDOWN)
            {
                new FDistanceFieldVolumeData(Ar); // distanceFieldData
            }

            if (!stripDataFlags.IsEditorDataStripped())
            {
                WireframeIndexBuffer = new FRawStaticIndexBuffer(Ar);
            }

            if (!stripDataFlags.IsClassDataStripped((byte)EClassDataStripFlag.CDSF_AdjacencyData))
            {
                AdjacencyIndexBuffer = new FRawStaticIndexBuffer(Ar);
            }

            if (Ar.Game >= EGame.GAME_UE4_16)
            {
                for (var i = 0; i < Sections.Length; i++)
                {
                    new FWeightedRandomSampler(Ar);
                }

                new FWeightedRandomSampler(Ar);
            }
        }
Example #2
0
        public FStaticMeshComponentLODInfo(FArchive Ar)
        {
            var stripFlags = new FStripDataFlags(Ar);

            if (!stripFlags.IsDataStrippedForServer())
            {
                MapBuildDataId = Ar.Read <FGuid>();
            }

            if (!stripFlags.IsClassDataStripped(OverrideColorsStripFlag))
            {
                var bLoadVertexColorData = Ar.Read <byte>();

                if (bLoadVertexColorData == 1)
                {
                    OverrideVertexColors = new FColorVertexBuffer(Ar);
                }
            }

            if (!stripFlags.IsEditorDataStripped())
            {
                PaintedVertices = Ar.ReadArray(() => new FPaintedVertex(Ar));
            }
        }
Example #3
0
        public override void Deserialize(FAssetArchive Ar, long validPos)
        {
            base.Deserialize(Ar, validPos);

            NumFrames = GetOrDefault <int>(nameof(NumFrames));
            BoneCompressionSettings          = GetOrDefault <ResolvedObject>(nameof(BoneCompressionSettings));
            CurveCompressionSettings         = GetOrDefault <ResolvedObject>(nameof(CurveCompressionSettings));
            AdditiveAnimType                 = GetOrDefault <EAdditiveAnimationType>(nameof(AdditiveAnimType));
            RetargetSource                   = GetOrDefault <FName>(nameof(RetargetSource));
            RetargetSourceAssetReferencePose = GetOrDefault <FTransform[]>(nameof(RetargetSourceAssetReferencePose));

            if (BoneCompressionSettings == null && Ar.Game == EGame.GAME_RogueCompany)
            {
                BoneCompressionSettings = new ResolvedLoadedObject(Owner !.Provider !.LoadObject("/Game/Animation/KSAnimBoneCompressionSettings.KSAnimBoneCompressionSettings"));
            }

            var stripFlags = new FStripDataFlags(Ar);

            if (!stripFlags.IsEditorDataStripped())
            {
                RawAnimationData = Ar.ReadArray(() => new FRawAnimSequenceTrack(Ar));
                if (Ar.Ver >= EUnrealEngineObjectUE4Version.ANIMATION_ADD_TRACKCURVES)
                {
                    if (FUE5MainStreamObjectVersion.Get(Ar) < FUE5MainStreamObjectVersion.Type.RemovingSourceAnimationData)
                    {
                        var sourceRawAnimationData = Ar.ReadArray(() => new FRawAnimSequenceTrack(Ar));
                        if (sourceRawAnimationData.Length > 0)
                        {
                            // Set RawAnimationData to Source
                            RawAnimationData = sourceRawAnimationData;
                        }
                    }
                }
            }

            if (FFrameworkObjectVersion.Get(Ar) < FFrameworkObjectVersion.Type.MoveCompressedAnimDataToTheDDC)
            {
                var compressedData = new FUECompressedAnimData();
                CompressedDataStructure = compressedData;

                // Part of data were serialized as properties
                compressedData.CompressedByteStream = Ar.ReadBytes(Ar.Read <int>());
                if (Ar.Game == EGame.GAME_SeaOfThieves && compressedData.CompressedByteStream.Length == 1 && Ar.Length - Ar.Position > 0)
                {
                    // Sea of Thieves has extra int32 == 1 before the CompressedByteStream
                    Ar.Position -= 1;
                    compressedData.CompressedByteStream = Ar.ReadBytes(Ar.Read <int>());
                }

                // Fix layout of "byte swapped" data (workaround for UE4 bug)
                if (compressedData.KeyEncodingFormat == AnimationKeyFormat.AKF_PerTrackCompression && compressedData.CompressedScaleOffsets.OffsetData.Length > 0)
                {
                    compressedData.CompressedByteStream = TransferPerTrackData(compressedData.CompressedByteStream);
                }
            }
            else
            {
                // UE4.12+
                var bSerializeCompressedData = Ar.ReadBoolean();

                if (bSerializeCompressedData)
                {
                    if (Ar.Game < EGame.GAME_UE4_23)
                    {
                        SerializeCompressedData(Ar);
                    }
                    else if (Ar.Game < EGame.GAME_UE4_25)
                    {
                        SerializeCompressedData2(Ar);
                    }
                    else
                    {
                        SerializeCompressedData3(Ar);
                    }

                    bUseRawDataOnly = Ar.ReadBoolean();
                }
            }
        }
Example #4
0
        // Pre-UE4.23 code
        public void SerializeBuffersLegacy(FAssetArchive Ar, FStripDataFlags stripDataFlags)
        {
            PositionVertexBuffer = new FPositionVertexBuffer(Ar);
            VertexBuffer         = new FStaticMeshVertexBuffer(Ar);

            if (Ar.Game == EGame.GAME_Borderlands3)
            {
                var numColorStreams = Ar.Read <int>();
                if (numColorStreams != 0)
                {
                    ColorVertexBuffer = new FColorVertexBuffer(Ar);
                    for (var i = 0; i < numColorStreams - 1; i++)
                    {
                        var _ = new FColorVertexBuffer(Ar);
                    }
                }
            }
            else
            {
                ColorVertexBuffer = new FColorVertexBuffer(Ar);
            }

            IndexBuffer = new FRawStaticIndexBuffer(Ar);

            if (Ar.Game != EGame.GAME_PlayerUnknownsBattlegrounds || !stripDataFlags.IsClassDataStripped((byte)EClassDataStripFlag.CDSF_StripIndexBuffers))
            {
                if (Ar.Ver >= EUnrealEngineObjectUE4Version.SOUND_CONCURRENCY_PACKAGE && !stripDataFlags.IsClassDataStripped((byte)EClassDataStripFlag.CDSF_ReversedIndexBuffer))
                {
                    ReversedIndexBuffer          = new FRawStaticIndexBuffer(Ar);
                    DepthOnlyIndexBuffer         = new FRawStaticIndexBuffer(Ar);
                    ReversedDepthOnlyIndexBuffer = new FRawStaticIndexBuffer(Ar);
                }
                else
                {
                    // UE4.8 or older, or when has CDSF_ReversedIndexBuffer
                    DepthOnlyIndexBuffer = new FRawStaticIndexBuffer(Ar);
                }

                if (Ar.Ver >= EUnrealEngineObjectUE4Version.FTEXT_HISTORY && Ar.Ver < EUnrealEngineObjectUE4Version.RENAME_CROUCHMOVESCHARACTERDOWN)
                {
                    var _ = new FDistanceFieldVolumeData(Ar); // distanceFieldData
                }

                if (!stripDataFlags.IsEditorDataStripped())
                {
                    WireframeIndexBuffer = new FRawStaticIndexBuffer(Ar);
                }

                if (!stripDataFlags.IsClassDataStripped((byte)EClassDataStripFlag.CDSF_AdjacencyData))
                {
                    AdjacencyIndexBuffer = new FRawStaticIndexBuffer(Ar);
                }
            }

            if (Ar.Game > EGame.GAME_UE4_16)
            {
                for (var i = 0; i < Sections.Length; i++)
                {
                    var _ = new FWeightedRandomSampler(Ar);
                }

                _ = new FWeightedRandomSampler(Ar);
            }
        }
Example #5
0
        public FStructFallback CompressedCurveData;                     // FRawCurveTracks

        public override void Deserialize(FAssetArchive Ar, long validPos)
        {
            base.Deserialize(Ar, validPos);
            var stripFlags = new FStripDataFlags(Ar);

            if (!stripFlags.IsEditorDataStripped())
            {
                RawAnimationData = Ar.ReadArray(() => new FRawAnimSequenceTrack(Ar));
                if (Ar.Ver >= UE4Version.VER_UE4_ANIMATION_ADD_TRACKCURVES)
                {
                    //if (FUE5MainStreamObjectVersion.Get(Ar) < FUE5MainStreamObjectVersion.Type.RemovingSourceAnimationData)
                    //{
                    var sourceRawAnimationData = Ar.ReadArray(() => new FRawAnimSequenceTrack(Ar));
                    //}
                }
            }

            if (FFrameworkObjectVersion.Get(Ar) < FFrameworkObjectVersion.Type.MoveCompressedAnimDataToTheDDC)
            {
                /*// Part of data were serialized as properties
                 * CompressedByteStream = Ar.ReadArray<byte>();
                 * if (Ar.Game == EGame.GAME_SEAOFTHIEVES && CompressedByteStream.Num() == 1 && Ar.Length - Ar.Position > 0)
                 * {
                 *  // Sea of Thieves has extra int32 == 1 before the CompressedByteStream
                 *  Ar.Position -= 1;
                 *  CompressedByteStream = Ar.ReadArray<byte>();
                 * }
                 *
                 * // Fix layout of "byte swapped" data (workaround for UE4 bug)
                 * if (KeyEncodingFormat == AnimationKeyFormat.AKF_PerTrackCompression && CompressedScaleOffsets.OffsetData.Length > 0)
                 * {
                 *  TArray<uint8> SwappedData;
                 *  TransferPerTrackData(SwappedData, CompressedByteStream);
                 *  Exchange(SwappedData, CompressedByteStream);
                 * }*/
                throw new NotImplementedException();
            }
            else
            {
                // UE4.12+
                var bSerializeCompressedData = Ar.ReadBoolean();

                if (bSerializeCompressedData)
                {
                    if (Ar.Game < EGame.GAME_UE4_23)
                    {
                        SerializeCompressedData(Ar);
                    }
                    else if (Ar.Game < EGame.GAME_UE4_25)
                    {
                        SerializeCompressedData2(Ar);
                    }
                    else
                    {
                        SerializeCompressedData3(Ar);
                    }

                    bUseRawDataOnly = Ar.ReadBoolean();
                }
            }
        }