fu

FModel/MainWindow.xaml.cs

@@ -84,6 +84,14 @@ private async void OnLoaded(object sender, RoutedEventArgs e)
         // await _threadWorkerView.Begin(cancellationToken =>
         //     _applicationView.CUE4Parse.Extract(cancellationToken,
         //         "FortniteGame/Content/Animation/Game/MainPlayer/Emotes/Acrobatic_Superhero/Emote_AcrobaticSuperhero_CMM.uasset"));
+#endif
+#if DEBUG
+        // await _threadWorkerView.Begin(cancellationToken =>
+        //     _applicationView.CUE4Parse.Extract(cancellationToken,
+        //         "Hk_project/Content/Character/Drone/Mesh/SKM_Drone.uasset"));
+        // await _threadWorkerView.Begin(cancellationToken =>
+        //     _applicationView.CUE4Parse.Extract(cancellationToken,
+        //         "Hk_project/Content/Animation/DRONE/B12_TestSpin360.uasset"));
 #endif
     }
 

FModel/Resources/default.vert

@@ -12,12 +12,12 @@ layout (location = 9) in mat4 vInstanceMatrix;
 layout (location = 13) in vec3 vMorphTargetPos;
 layout (location = 14) in vec3 vMorphTargetTangent;
 
-const int MAX_BONES = 140;
+//const int MAX_BONES = 140;
 
 uniform mat4 uView;
 uniform mat4 uProjection;
 uniform float uMorphTime;
-uniform mat4 uFinalBonesMatrix[MAX_BONES];
+//uniform mat4 uFinalBonesMatrix[MAX_BONES];
 
 out vec3 fPos;
 out vec3 fNormal;
@@ -29,23 +29,28 @@ out vec4 fColor;
 void main()
 {
     vec4 bindPos = vec4(mix(vPos, vMorphTargetPos, uMorphTime), 1.0);
-    vec3 tangent = mix(vTangent, vMorphTargetTangent, uMorphTime);
-
-    vec4 finalPos = vec4(0.0);
-    vec4 weights = normalize(vBoneWeights);
-    for(int i = 0 ; i < 4; i++)
-    {
-        int boneIndex = int(vBoneIds[i]);
-        if(boneIndex < 0) break;
-
-        finalPos += inverse(uFinalBonesMatrix[boneIndex]) * bindPos * weights[i];
-    }
+    vec4 bindNormal = vec4(vNormal, 1.0);
+    vec4 bindTangent = vec4(mix(vTangent, vMorphTargetTangent, uMorphTime), 1.0);
+
+//    vec4 finalPos = vec4(0.0);
+//    vec4 finalNormal = vec4(0.0);
+//    vec4 finalTangent = vec4(0.0);
+//    vec4 weights = normalize(vBoneWeights);
+//    for(int i = 0 ; i < 4; i++)
+//    {
+//        int boneIndex = int(vBoneIds[i]);
+//        if(boneIndex < 0) break;
+//
+//        finalPos += uFinalBonesMatrix[boneIndex] * bindPos * weights[i];
+//        finalNormal += uFinalBonesMatrix[boneIndex] * bindNormal * weights[i];
+//        finalTangent += uFinalBonesMatrix[boneIndex] * bindTangent * weights[i];
+//    }
 
     gl_Position = uProjection * uView * vInstanceMatrix * bindPos;
 
     fPos = vec3(vInstanceMatrix * bindPos);
-    fNormal = mat3(transpose(inverse(vInstanceMatrix))) * vNormal;
-    fTangent = mat3(transpose(inverse(vInstanceMatrix))) * tangent;
+    fNormal = vec3(transpose(inverse(vInstanceMatrix)) * bindNormal);
+    fTangent = vec3(transpose(inverse(vInstanceMatrix)) * bindTangent);
     fTexCoords = vTexCoords;
     fTexLayer = vTexLayer;
     fColor = vColor;

FModel/Views/Snooper/Lights/Light.cs

@@ -28,6 +28,7 @@ public abstract class Light : IDisposable
         1f,  1f, 0f,
         1f, -1f, 0
     };
+    public string Name;
     public readonly FGuid Model;
     public readonly Texture Icon;
     public Transform Transform;

FModel/Views/Snooper/Models/Animations/Animation.cs

@@ -1,62 +1,52 @@
 using System;
-using System.Collections.Generic;
 using System.Numerics;
 using CUE4Parse_Conversion.Animations;
-using CUE4Parse.UE4.Assets.Exports.Animation;
 using CUE4Parse.UE4.Objects.Core.Math;
 
 namespace FModel.Views.Snooper.Models.Animations;
 
 public class Animation : IDisposable
 {
     public int CurrentTime;
-    public float DeltaTime;
-    public CAnimSet CurrentAnimation;
+    public readonly int MaxTime;
+    public readonly Transform[][] BoneTransforms;
 
-    public Animation(CAnimSet anim)
+    public Animation(Skeleton skeleton, CAnimSet anim)
     {
-        CurrentTime = 1;
-        CurrentAnimation = anim;
-    }
+        CurrentTime = 0;
 
-    public Dictionary<int, Transform> CalculateBoneTransform(FMeshBoneInfo[] boneInfos, Dictionary<int, Transform> bonesTransformByIndex)
-    {
-        var ret = new Dictionary<int, Transform>();
-        var sequence = CurrentAnimation.Sequences[0];
-        for (int boneIndex = 0; boneIndex < boneInfos.Length; boneIndex++)
+        var sequence = anim.Sequences[0];
+        MaxTime = sequence.NumFrames - 1;
+        BoneTransforms = new Transform[skeleton.BonesTransformByIndex.Count][];
+        for (var boneIndex = 0; boneIndex < BoneTransforms.Length; boneIndex++)
         {
-            var boneOrientation = FQuat.Identity;
-            var bonePosition = FVector.ZeroVector;
-            var boneScale = FVector.OneVector;
-            sequence.Tracks[boneIndex].GetBonePosition(CurrentTime, sequence.NumFrames, false, ref bonePosition, ref boneOrientation);
-            if (CurrentTime < sequence.Tracks[boneIndex].KeyScale.Length)
-                boneScale = sequence.Tracks[boneIndex].KeyScale[CurrentTime];
+            var parentIndex = skeleton.ReferenceSkeleton.FinalRefBoneInfo[boneIndex].ParentIndex;
+            if (!skeleton.BonesTransformByIndex.TryGetValue(boneIndex, out var originalTransform))
+                throw new ArgumentNullException("no transform for bone " + boneIndex);
 
-            if (!bonesTransformByIndex.TryGetValue(boneIndex, out var originalTransform))
-                originalTransform = new Transform { Relation = Matrix4x4.Identity };
+            var boneOrientation = originalTransform.Rotation;
+            var bonePosition = originalTransform.Position;
+            var boneScale = originalTransform.Scale;
 
-            if (!ret.TryGetValue(boneInfos[boneIndex].ParentIndex, out var parentTransform))
-                parentTransform = new Transform { Relation = Matrix4x4.Identity };
-            else boneOrientation.Conjugate();
-
-            var boneTransform = new Transform
+            BoneTransforms[boneIndex] = new Transform[sequence.NumFrames];
+            for (var frame = 0; frame < BoneTransforms[boneIndex].Length; frame++)
             {
-                Relation = parentTransform.Matrix,
-                Rotation = boneOrientation * originalTransform.Rotation * FQuat.Conjugate(boneOrientation),
-                Position = bonePosition * Constants.SCALE_DOWN_RATIO,
-                Scale = boneScale
-            };
-
-            // boneTransform.Rotation = originalTransform.Rotation * FQuat.Conjugate(originalTransform.Rotation) * parentTransform.Rotation
-            boneTransform.Position -= boneTransform.Position - originalTransform.Position;
-
-            // boneTransform.Rotation = originalTransform.Rotation * (boneTransform.Rotation * FQuat.Conjugate(originalTransform.Rotation));
-            // boneTransform.Position = originalTransform.Position + (boneTransform.Position - originalTransform.Position);
-
-            ret[boneIndex] = boneTransform;
+                sequence.Tracks[boneIndex].GetBonePosition(frame, sequence.NumFrames, false, ref bonePosition, ref boneOrientation);
+                if (CurrentTime < sequence.Tracks[boneIndex].KeyScale.Length)
+                    boneScale = sequence.Tracks[boneIndex].KeyScale[CurrentTime];
+
+                boneOrientation.W *= -1;
+                bonePosition *= Constants.SCALE_DOWN_RATIO;
+
+                BoneTransforms[boneIndex][frame] = new Transform
+                {
+                    Relation = parentIndex >= 0 ? BoneTransforms[parentIndex][frame].Matrix : originalTransform.Relation,
+                    Rotation = boneOrientation,
+                    Position = bonePosition,
+                    Scale = boneScale
+                };
+            }
         }
-
-        return ret;
     }
 
     public void Dispose()

FModel/Views/Snooper/Models/Animations/Skeleton.cs

@@ -13,8 +13,7 @@ public class Skeleton : IDisposable
     public readonly USkeleton UnrealSkeleton;
     public readonly FReferenceSkeleton ReferenceSkeleton;
     public readonly Dictionary<string, int> BonesIndexByName;
-    public Dictionary<int, Transform> BonesTransformByIndex;
-    public Dictionary<int, Transform> AnimBonesTransformByIndex;
+    public readonly Dictionary<int, Transform> BonesTransformByIndex;
     public readonly bool IsLoaded;
 
     public Animation Anim;
@@ -23,7 +22,6 @@ public Skeleton()
     {
         BonesIndexByName = new Dictionary<string, int>();
         BonesTransformByIndex = new Dictionary<int, Transform>();
-        AnimBonesTransformByIndex = new Dictionary<int, Transform>();
     }
 
     public Skeleton(FPackageIndex package, FReferenceSkeleton referenceSkeleton, Transform transform) : this()
@@ -32,14 +30,21 @@ public Skeleton(FPackageIndex package, FReferenceSkeleton referenceSkeleton, Tra
         IsLoaded = UnrealSkeleton != null;
         if (!IsLoaded) return;
 
-        ReferenceSkeleton = referenceSkeleton ?? UnrealSkeleton.ReferenceSkeleton;
+        ReferenceSkeleton = UnrealSkeleton.ReferenceSkeleton;
+        foreach ((var name, var boneIndex) in ReferenceSkeleton.FinalNameToIndexMap)
+        {
+            if (!referenceSkeleton.FinalNameToIndexMap.TryGetValue(name, out var newBoneIndex))
+                continue;
+
+            ReferenceSkeleton.FinalRefBonePose[boneIndex] = referenceSkeleton.FinalRefBonePose[newBoneIndex];
+        }
         BonesIndexByName = ReferenceSkeleton.FinalNameToIndexMap;
         UpdateBoneMatrices(transform.Matrix);
     }
 
     public void SetAnimation(CAnimSet anim)
     {
-        Anim = new Animation(anim);
+        Anim = new Animation(this, anim);
     }
 
     public void UpdateBoneMatrices(Matrix4x4 matrix)
@@ -64,17 +69,16 @@ public void UpdateBoneMatrices(Matrix4x4 matrix)
                 parentTransform = new Transform { Relation = matrix };
 
             boneTransform.Relation = parentTransform.Matrix;
-            BonesTransformByIndex[boneIndex] = AnimBonesTransformByIndex[boneIndex] = boneTransform;
+            BonesTransformByIndex[boneIndex] = boneTransform;
         }
     }
 
     public void SetUniform(Shader shader)
     {
         if (!IsLoaded || Anim == null) return;
-        AnimBonesTransformByIndex = Anim.CalculateBoneTransform(ReferenceSkeleton.FinalRefBoneInfo, BonesTransformByIndex);
-        foreach ((int boneIndex, Transform boneTransform) in AnimBonesTransformByIndex)
+        for (int boneIndex = 0; boneIndex < Anim.BoneTransforms.Length; boneIndex++)
         {
-            shader.SetUniform($"uFinalBonesMatrix[{boneIndex}]", boneTransform.Matrix);
+            shader.SetUniform($"uFinalBonesMatrix[{boneIndex}]", Anim.BoneTransforms[boneIndex][Anim.CurrentTime].Matrix);
         }
     }
 

FModel/Views/Snooper/Models/Model.cs

@@ -230,10 +230,13 @@ public void AddInstance(Transform transform)
     public void UpdateMatrices(Options options)
     {
         UpdateMatrices();
-        for (int i = 0; i < options.Lights.Count; i++)
+        if (HasSkeleton && Skeleton.Anim != null)
         {
-            options.Lights[i].Transform = Skeleton.AnimBonesTransformByIndex[i];
-            options.Lights[i].UpdateMatrices();
+            for (int i = 0; i < options.Lights.Count; i++)
+            {
+                options.Lights[i].Transform = Skeleton.Anim.BoneTransforms[i][Skeleton.Anim.CurrentTime];
+                options.Lights[i].UpdateMatrices();
+            }
         }
 
         foreach (var socket in Sockets)

FModel/Views/Snooper/Renderer.cs

@@ -178,10 +178,12 @@ private void LoadSkeletalMesh(USkeletalMesh original)
         if (Options.Models.ContainsKey(guid) || !original.TryConvert(out var mesh)) return;
 
         Options.Models[guid] = new Model(original, mesh);
-        foreach (var transform in Options.Models[guid].Skeleton.BonesTransformByIndex.Values)
+        foreach ((var name, var index) in Options.Models[guid].Skeleton.BonesIndexByName)
         {
+            if (!Options.Models[guid].Skeleton.BonesTransformByIndex.TryGetValue(index, out var transform)) continue;
+
             Options.Lights.Add(
-                new PointLight(guid, Options.Icons["pointlight"], original, original, transform));
+                new PointLight(guid, Options.Icons["pointlight"], original, original, transform) { Name = name});
         }
         Options.SelectModel(guid);
         SetupCamera(Options.Models[guid].Box);

FModel/Views/Snooper/SnimGui.cs

@@ -159,9 +159,7 @@ private void DrawWorld(Snooper s)
             for (int i = 0; i < s.Renderer.Options.Lights.Count; i++)
             {
                 var light = s.Renderer.Options.Lights[i];
-                var id = s.Renderer.Options.TryGetModel(light.Model, out var lightModel) ? lightModel.Name : "None";
-
-                id += $"##{i}";
+                var id = $"{light.Name}##{i}";
                 if (ImGui.TreeNode(id) && ImGui.BeginTable(id, 2))
                 {
                     s.Renderer.Options.SelectModel(light.Model);
@@ -448,7 +446,7 @@ private void DrawDetails(Snooper s)
                 {
                     if (model.Skeleton.Anim != null)
                     {
-                        ImGui.DragInt("Time", ref model.Skeleton.Anim.CurrentTime, 1, 0, 110);
+                        ImGui.DragInt("Time", ref model.Skeleton.Anim.CurrentTime, 1, 0, model.Skeleton.Anim.MaxTime);
                     }
                     Layout("Skeleton");ImGui.Text($"  :  {model.Skeleton.UnrealSkeleton.Name}");
                     Layout("Bones");ImGui.Text($"  :  x{model.Skeleton.UnrealSkeleton.BoneTree.Length}");