Merge pull request #550 from 4sval/on-hold

4sval · web-flow · commit 34116d62b27d · 2025-02-16T00:23:44.000+01:00
On hold
diff --git a/CUE4Parse b/CUE4Parse
@@ -1 +1 @@
-Subproject commit 9a63be6718300901eebe6af9c65908c2c69c67b0
+Subproject commit c36748f206d19eea45a6f2ea4cc82e56617d87c9
diff --git a/FModel/ViewModels/ApiEndpoints/AbstractApiProvider.cs b/FModel/ViewModels/ApiEndpoints/AbstractApiProvider.cs
@@ -1,13 +1,19 @@
 ﻿using RestSharp;
+using RestSharp.Interceptors;
 
 namespace FModel.ViewModels.ApiEndpoints;
 
 public abstract class AbstractApiProvider
 {
     protected readonly RestClient _client;
+    protected readonly Interceptor _interceptor;
 
     protected AbstractApiProvider(RestClient client)
     {
         _client = client;
+        _interceptor = new CompatibilityInterceptor
+        {
+            OnBeforeDeserialization = resp => { resp.ContentType = "application/json; charset=utf-8"; }
+        };
     }
 }
diff --git a/FModel/ViewModels/ApiEndpoints/DynamicApiEndpoint.cs b/FModel/ViewModels/ApiEndpoints/DynamicApiEndpoint.cs
@@ -66,7 +66,7 @@ public async Task<JToken> GetRequestBody(CancellationToken token, string url)
     {
         var request = new FRestRequest(url)
         {
-            OnBeforeDeserialization = resp => { resp.ContentType = "application/json; charset=utf-8"; }
+            Interceptors = [_interceptor]
         };
         var response = await _client.ExecuteAsync(request, token).ConfigureAwait(false);
         Log.Information("[{Method}] [{Status}({StatusCode})] '{Resource}'", request.Method, response.StatusDescription, (int) response.StatusCode, response.ResponseUri?.OriginalString);
diff --git a/FModel/ViewModels/ApiEndpoints/FortniteCentralApiEndpoint.cs b/FModel/ViewModels/ApiEndpoints/FortniteCentralApiEndpoint.cs
@@ -15,7 +15,7 @@ public async Task<Dictionary<string, Dictionary<string, string>>> GetHotfixesAsy
     {
         var request = new FRestRequest("https://fortnitecentral.genxgames.gg/api/v1/hotfixes")
         {
-            OnBeforeDeserialization = resp => { resp.ContentType = "application/json; charset=utf-8"; }
+            Interceptors = [_interceptor]
         };
         request.AddParameter("lang", language);
         var response = await _client.ExecuteAsync<Dictionary<string, Dictionary<string, string>>>(request, token).ConfigureAwait(false);
diff --git a/FModel/ViewModels/BackupManagerViewModel.cs b/FModel/ViewModels/BackupManagerViewModel.cs
@@ -66,7 +66,7 @@ await _threadWorkerView.Begin(_ =>
             var backupFolder = Path.Combine(UserSettings.Default.OutputDirectory, "Backups");
             var fileName = $"{_gameName}_{DateTime.Now:MM'_'dd'_'yyyy}.fbkp";
             var fullPath = Path.Combine(backupFolder, fileName);
-            var func = new Func<GameFile, bool>(x => !x.Path.EndsWith(".uexp") && !x.Path.EndsWith(".ubulk") && !x.Path.EndsWith(".uptnl"));
+            var func = new Func<GameFile, bool>(x => !x.IsUePackagePayload);
 
             using var fileStream = new FileStream(fullPath, FileMode.Create);
             using var compressedStream = LZ4Stream.Encode(fileStream, LZ4Level.L00_FAST);
@@ -80,7 +80,7 @@ await _threadWorkerView.Begin(_ =>
                 if (!func(asset)) continue;
                 writer.Write(asset.Size);
                 writer.Write(asset.IsEncrypted);
-                writer.Write($"/{asset.Path.ToLower()}");
+                writer.Write(asset.Path);
             }
 
             SaveCheck(fullPath, fileName, "created", "create");
@@ -121,6 +121,7 @@ public enum EBackupVersion : byte
 {
     BeforeVersionWasAdded = 0,
     Initial,
+    PerfectPath, // no more leading slash and ToLower
 
     LatestPlusOne,
     Latest = LatestPlusOne - 1
diff --git a/FModel/ViewModels/Commands/LoadCommand.cs b/FModel/ViewModels/Commands/LoadCommand.cs
@@ -182,7 +182,7 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT
         {
             case ELoadingMode.AllButNew:
             {
-                var paths = new HashSet<string>();
+                var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
                 var magic = archive.Read<uint>();
                 if (magic != BackupManagerViewModel.FBKP_MAGIC)
                 {
@@ -192,7 +192,7 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT
                         cancellationToken.ThrowIfCancellationRequested();
 
                         archive.Position += 29;
-                        paths.Add(archive.ReadString().ToLower()[1..]);
+                        paths.Add(archive.ReadString()[1..]);
                         archive.Position += 4;
                     }
                 }
@@ -205,7 +205,10 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT
                         cancellationToken.ThrowIfCancellationRequested();
 
                         archive.Position += sizeof(long) + sizeof(byte);
-                        paths.Add(archive.ReadString().ToLower()[1..]);
+                        var fullPath = archive.ReadString();
+                        if (version < EBackupVersion.PerfectPath) fullPath = fullPath[1..];
+
+                        paths.Add(fullPath);
                     }
                 }
 
@@ -233,7 +236,7 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT
                         var uncompressedSize = archive.Read<long>();
                         var isEncrypted = archive.ReadFlag();
                         archive.Position += 4;
-                        var fullPath = archive.ReadString().ToLower()[1..];
+                        var fullPath = archive.ReadString()[1..];
                         archive.Position += 4;
 
                         AddEntry(fullPath, uncompressedSize, isEncrypted, entries);
@@ -249,7 +252,8 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT
 
                         var uncompressedSize = archive.Read<long>();
                         var isEncrypted = archive.ReadFlag();
-                        var fullPath = archive.ReadString().ToLower()[1..];
+                        var fullPath = archive.ReadString();
+                        if (version < EBackupVersion.PerfectPath) fullPath = fullPath[1..];
 
                         AddEntry(fullPath, uncompressedSize, isEncrypted, entries);
                     }
diff --git a/FModel/Views/Snooper/Animations/Animation.cs b/FModel/Views/Snooper/Animations/Animation.cs
@@ -35,9 +35,9 @@ public Animation(UObject export)
         _export = export;
         Path = _export.GetPathName();
         Name = _export.Name;
-        Sequences = Array.Empty<Sequence>();
+        Sequences = [];
         Framing = new Dictionary<int, float>();
-        AttachedModels = new List<FGuid>();
+        AttachedModels = [];
     }
 
     public Animation(UObject export, CAnimSet animSet) : this(export)
diff --git a/FModel/Views/Snooper/Animations/TimeTracker.cs b/FModel/Views/Snooper/Animations/TimeTracker.cs
@@ -20,7 +20,7 @@ public class TimeTracker : IDisposable
     public bool IsActive;
     public float ElapsedTime;
     public float MaxElapsedTime;
-    public int TimeMultiplier;
+    public float TimeMultiplier;
 
     public TimeTracker()
     {
@@ -51,7 +51,7 @@ public void Reset(bool doMet = true)
         if (doMet)
         {
             MaxElapsedTime = 0.01f;
-            TimeMultiplier = 1;
+            TimeMultiplier = 1f;
         }
     }
 
diff --git a/FModel/Views/Snooper/Models/SkeletalModel.cs b/FModel/Views/Snooper/Models/SkeletalModel.cs
@@ -153,7 +153,7 @@ public override void RenderCollision(Shader shader)
 
         GL.Disable(EnableCap.DepthTest);
         GL.Disable(EnableCap.CullFace);
-        GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
+        GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Line);
         foreach (var collision in Collisions)
         {
             var boneMatrix = Matrix4x4.Identity;
@@ -162,7 +162,7 @@ public override void RenderCollision(Shader shader)
 
             collision.Render(shader, boneMatrix);
         }
-        GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
+        GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Fill);
         GL.Enable(EnableCap.CullFace);
         GL.Enable(EnableCap.DepthTest);
     }
diff --git a/FModel/Views/Snooper/Models/StaticModel.cs b/FModel/Views/Snooper/Models/StaticModel.cs
@@ -148,12 +148,12 @@ public override void RenderCollision(Shader shader)
         base.RenderCollision(shader);
 
         GL.Disable(EnableCap.CullFace);
-        GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
+        GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Line);
         foreach (var collision in Collisions)
         {
             collision.Render(shader, Matrix4x4.Identity);
         }
-        GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
+        GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Fill);
         GL.Enable(EnableCap.CullFace);
     }
 }
diff --git a/FModel/Views/Snooper/Models/UModel.cs b/FModel/Views/Snooper/Models/UModel.cs
@@ -255,7 +255,7 @@ public virtual void Render(Shader shader, Texture checker = null, bool outline =
         }
 
         Vao.Bind();
-        GL.PolygonMode(MaterialFace.FrontAndBack, ShowWireframe ? PolygonMode.Line : PolygonMode.Fill);
+        GL.PolygonMode(TriangleFace.FrontAndBack, ShowWireframe ? PolygonMode.Line : PolygonMode.Fill);
         foreach (var section in Sections)
         {
             if (!section.Show) continue;
@@ -275,7 +275,7 @@ public virtual void Render(Shader shader, Texture checker = null, bool outline =
 
             GL.DrawElementsInstanced(PrimitiveType.Triangles, section.FacesCount, DrawElementsType.UnsignedInt, section.FirstFaceIndexPtr, TransformsCount);
         }
-        GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
+        GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Fill);
         Vao.Unbind();
 
         if (IsSelected)
diff --git a/FModel/Views/Snooper/Renderer.cs b/FModel/Views/Snooper/Renderer.cs
@@ -122,111 +122,90 @@ public void Swap(UMaterialInstance unrealMaterial)
     public void Animate(Lazy<UObject> anim) => Animate(anim.Value, Options.SelectedModel);
     private void Animate(UObject anim, FGuid guid)
     {
-        if (!Options.TryGetModel(guid, out var m) || m is not SkeletalModel model)
+        if (anim is not UAnimSequenceBase animBase || !animBase.Skeleton.TryLoad(out USkeleton skeleton) ||
+            !Options.TryGetModel(guid, out var m) || m is not SkeletalModel model)
             return;
 
-        float maxElapsedTime;
-        switch (anim)
+        var animSet = animBase switch
         {
-            case UAnimSequence animSequence when animSequence.Skeleton.TryLoad(out USkeleton skeleton):
+            UAnimSequence animSequence => skeleton.ConvertAnims(animSequence),
+            UAnimMontage animMontage => skeleton.ConvertAnims(animMontage),
+            UAnimComposite animComposite => skeleton.ConvertAnims(animComposite),
+            _ => throw new ArgumentException("Unknown animation type")
+        };
+
+        var animation = new Animation(anim, animSet, guid);
+        model.Skeleton.Animate(animSet);
+        Options.AddAnimation(animation);
+
+        foreach (var notifyEvent in animBase.Notifies)
+        {
+            if (!notifyEvent.NotifyStateClass.TryLoad(out UObject notifyClass) ||
+                !notifyClass.TryGetValue(out UObject export, "SkeletalMeshProp", "StaticMeshProp", "Mesh", "SkeletalMeshTemplate"))
+                continue;
+
+            var t = Transform.Identity;
+            if (notifyClass.TryGetValue(out FTransform offset, "Offset"))
             {
-                var animSet = skeleton.ConvertAnims(animSequence);
-                var animation = new Animation(animSequence, animSet, guid);
-                maxElapsedTime = animation.TotalElapsedTime;
-                model.Skeleton.Animate(animSet);
-                Options.AddAnimation(animation);
-                break;
+                t.Rotation = offset.Rotation;
+                t.Position = offset.Translation * Constants.SCALE_DOWN_RATIO;
+                t.Scale = offset.Scale3D;
             }
-            case UAnimMontage animMontage when animMontage.Skeleton.TryLoad(out USkeleton skeleton):
-            {
-                var animSet = skeleton.ConvertAnims(animMontage);
-                var animation = new Animation(animMontage, animSet, guid);
-                maxElapsedTime = animation.TotalElapsedTime;
-                model.Skeleton.Animate(animSet);
-                Options.AddAnimation(animation);
 
-                foreach (var notifyEvent in animMontage.Notifies)
+            UModel addedModel = null;
+            switch (export)
+            {
+                case UStaticMesh st:
                 {
-                    if (!notifyEvent.NotifyStateClass.TryLoad(out UObject notifyClass) ||
-                        !notifyClass.TryGetValue(out FPackageIndex meshProp, "SkeletalMeshProp", "StaticMeshProp", "Mesh") ||
-                        !meshProp.TryLoad(out UObject export)) continue;
-
-                    var t = Transform.Identity;
-                    if (notifyClass.TryGetValue(out FTransform offset, "Offset"))
+                    guid = st.LightingGuid;
+                    if (Options.TryGetModel(guid, out addedModel))
                     {
-                        t.Rotation = offset.Rotation;
-                        t.Position = offset.Translation * Constants.SCALE_DOWN_RATIO;
-                        t.Scale = offset.Scale3D;
+                        addedModel.AddInstance(t);
                     }
-
-                    UModel addedModel = null;
-                    switch (export)
+                    else if (st.TryConvert(out var mesh))
                     {
-                        case UStaticMesh st:
-                        {
-                            guid = st.LightingGuid;
-                            if (Options.TryGetModel(guid, out addedModel))
-                            {
-                                addedModel.AddInstance(t);
-                            }
-                            else if (st.TryConvert(out var mesh))
-                            {
-                                addedModel = new StaticModel(st, mesh, t);
-                                Options.Models[guid] = addedModel;
-                            }
-                            break;
-                        }
-                        case USkeletalMesh sk:
-                        {
-                            guid = Guid.NewGuid();
-                            if (!Options.Models.ContainsKey(guid) && sk.TryConvert(out var mesh))
-                            {
-                                addedModel = new SkeletalModel(sk, mesh, t);
-                                Options.Models[guid] = addedModel;
-                            }
-                            break;
-                        }
+                        addedModel = new StaticModel(st, mesh, t);
+                        Options.Models[guid] = addedModel;
                     }
-
-                    if (addedModel == null)
-                        throw new ArgumentException("Unknown model type");
-
-                    addedModel.IsProp = true;
-                    if (notifyClass.TryGetValue(out UObject skeletalMeshPropAnimation, "SkeletalMeshPropAnimation", "Animation"))
-                        Animate(skeletalMeshPropAnimation, guid);
-                    if (notifyClass.TryGetValue(out FName socketName, "SocketName"))
+                    break;
+                }
+                case USkeletalMesh sk:
+                {
+                    guid = Guid.NewGuid();
+                    if (!Options.Models.ContainsKey(guid) && sk.TryConvert(out var mesh))
                     {
-                        t = Transform.Identity;
-                        if (notifyClass.TryGetValue(out FVector location, "LocationOffset", "Location"))
-                            t.Position = location * Constants.SCALE_DOWN_RATIO;
-                        if (notifyClass.TryGetValue(out FRotator rotation, "RotationOffset", "Rotation"))
-                            t.Rotation = rotation.Quaternion();
-                        if (notifyClass.TryGetValue(out FVector scale, "Scale"))
-                            t.Scale = scale;
-
-                        var s = new Socket($"ANIM_{addedModel.Name}", socketName, t, true);
-                        model.Sockets.Add(s);
-                        addedModel.Attachments.Attach(model, addedModel.GetTransform(), s,
-                            new SocketAttachementInfo { Guid = guid, Instance = addedModel.SelectedInstance });
+                        addedModel = new SkeletalModel(sk, mesh, t);
+                        Options.Models[guid] = addedModel;
                     }
+                    break;
                 }
-                break;
             }
-            case UAnimComposite animComposite when animComposite.Skeleton.TryLoad(out USkeleton skeleton):
+
+            if (addedModel == null)
+                throw new ArgumentException("Unknown model type");
+
+            addedModel.IsProp = true;
+            if (notifyClass.TryGetValue(out UObject skeletalMeshPropAnimation, "SkeletalMeshPropAnimation", "Animation", "AnimToPlay"))
+                Animate(skeletalMeshPropAnimation, guid);
+            if (notifyClass.TryGetValue(out FName socketName, "SocketName"))
             {
-                var animSet = skeleton.ConvertAnims(animComposite);
-                var animation = new Animation(animComposite, animSet, guid);
-                maxElapsedTime = animation.TotalElapsedTime;
-                model.Skeleton.Animate(animSet);
-                Options.AddAnimation(animation);
-                break;
+                t = Transform.Identity;
+                if (notifyClass.TryGetValue(out FVector location, "LocationOffset", "Location"))
+                    t.Position = location * Constants.SCALE_DOWN_RATIO;
+                if (notifyClass.TryGetValue(out FRotator rotation, "RotationOffset", "Rotation"))
+                    t.Rotation = rotation.Quaternion();
+                if (notifyClass.TryGetValue(out FVector scale, "Scale"))
+                    t.Scale = scale;
+
+                var s = new Socket($"ANIM_{addedModel.Name}", socketName, t, true);
+                model.Sockets.Add(s);
+                addedModel.Attachments.Attach(model, addedModel.GetTransform(), s,
+                    new SocketAttachementInfo { Guid = guid, Instance = addedModel.SelectedInstance });
             }
-            default:
-                throw new ArgumentException();
         }
 
         Options.Tracker.IsPaused = false;
-        Options.Tracker.SafeSetMaxElapsedTime(maxElapsedTime);
+        Options.Tracker.SafeSetMaxElapsedTime(animation.TotalElapsedTime);
     }
 
     public void Setup()
diff --git a/FModel/Views/Snooper/SnimGui.cs b/FModel/Views/Snooper/SnimGui.cs
@@ -218,7 +218,7 @@ private void DrawWorld(Snooper s)
             Layout("Animate With Rotation Only");ImGui.PushID(1);
             ImGui.Checkbox("", ref s.Renderer.AnimateWithRotationOnly);
             ImGui.PopID();Layout("Time Multiplier");ImGui.PushID(2);
-            ImGui.DragInt("", ref s.Renderer.Options.Tracker.TimeMultiplier, 0.1f, 1, 8, "x%i", ImGuiSliderFlags.NoInput);
+            ImGui.DragFloat("", ref s.Renderer.Options.Tracker.TimeMultiplier, 0.01f, 0.25f, 8f, "x%.2f", ImGuiSliderFlags.NoInput);
             ImGui.PopID();Layout("Vertex Colors");ImGui.PushID(3);
             var c = (int) s.Renderer.Color;
             ImGui.Combo("vertex_colors", ref c,

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,19 @@`
`1`	`1`	`using RestSharp;`
	`2`	`+using RestSharp.Interceptors;`
`2`	`3`
`3`	`4`	`namespace FModel.ViewModels.ApiEndpoints;`
`4`	`5`
`5`	`6`	`public abstract class AbstractApiProvider`
`6`	`7`	`{`
`7`	`8`	`protected readonly RestClient _client;`
	`9`	`+ protected readonly Interceptor _interceptor;`
`8`	`10`
`9`	`11`	`protected AbstractApiProvider(RestClient client)`
`10`	`12`	`{`
`11`	`13`	`_client = client;`
	`14`	`+ _interceptor = new CompatibilityInterceptor`
	`15`	`+ {`
	`16`	`+ OnBeforeDeserialization = resp => { resp.ContentType = "application/json; charset=utf-8"; }`
	`17`	`+ };`
`12`	`18`	`}`
`13`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ public async Task<JToken> GetRequestBody(CancellationToken token, string url)`
`66`	`66`	`{`
`67`	`67`	`var request = new FRestRequest(url)`
`68`	`68`	`{`
`69`		`- OnBeforeDeserialization = resp => { resp.ContentType = "application/json; charset=utf-8"; }`
	`69`	`+ Interceptors = [_interceptor]`
`70`	`70`	`};`
`71`	`71`	`var response = await _client.ExecuteAsync(request, token).ConfigureAwait(false);`
`72`	`72`	`Log.Information("[{Method}] [{Status}({StatusCode})] '{Resource}'", request.Method, response.StatusDescription, (int) response.StatusCode, response.ResponseUri?.OriginalString);`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public async Task<Dictionary<string, Dictionary<string, string>>> GetHotfixesAsy`
`15`	`15`	`{`
`16`	`16`	`var request = new FRestRequest("https://fortnitecentral.genxgames.gg/api/v1/hotfixes")`
`17`	`17`	`{`
`18`		`- OnBeforeDeserialization = resp => { resp.ContentType = "application/json; charset=utf-8"; }`
	`18`	`+ Interceptors = [_interceptor]`
`19`	`19`	`};`
`20`	`20`	`request.AddParameter("lang", language);`
`21`	`21`	`var response = await _client.ExecuteAsync<Dictionary<string, Dictionary<string, string>>>(request, token).ConfigureAwait(false);`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT`
`182`	`182`	`{`
`183`	`183`	`case ELoadingMode.AllButNew:`
`184`	`184`	`{`
`185`		`- var paths = new HashSet<string>();`
	`185`	`+ var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);`
`186`	`186`	`var magic = archive.Read<uint>();`
`187`	`187`	`if (magic != BackupManagerViewModel.FBKP_MAGIC)`
`188`	`188`	`{`
`@@ -192,7 +192,7 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT`
`192`	`192`	`cancellationToken.ThrowIfCancellationRequested();`
`193`	`193`
`194`	`194`	`archive.Position += 29;`
`195`		`- paths.Add(archive.ReadString().ToLower()[1..]);`
	`195`	`+ paths.Add(archive.ReadString()[1..]);`
`196`	`196`	`archive.Position += 4;`
`197`	`197`	`}`
`198`	`198`	`}`
`@@ -205,7 +205,10 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT`
`205`	`205`	`cancellationToken.ThrowIfCancellationRequested();`
`206`	`206`
`207`	`207`	`archive.Position += sizeof(long) + sizeof(byte);`
`208`		`- paths.Add(archive.ReadString().ToLower()[1..]);`
	`208`	`+ var fullPath = archive.ReadString();`
	`209`	`+ if (version < EBackupVersion.PerfectPath) fullPath = fullPath[1..];`
	`210`	`+`
	`211`	`+ paths.Add(fullPath);`
`209`	`212`	`}`
`210`	`213`	`}`
`211`	`214`
`@@ -233,7 +236,7 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT`
`233`	`236`	`var uncompressedSize = archive.Read<long>();`
`234`	`237`	`var isEncrypted = archive.ReadFlag();`
`235`	`238`	`archive.Position += 4;`
`236`		`- var fullPath = archive.ReadString().ToLower()[1..];`
	`239`	`+ var fullPath = archive.ReadString()[1..];`
`237`	`240`	`archive.Position += 4;`
`238`	`241`
`239`	`242`	`AddEntry(fullPath, uncompressedSize, isEncrypted, entries);`
`@@ -249,7 +252,8 @@ private List<GameFile> ParseBackup(string path, ELoadingMode mode, CancellationT`
`249`	`252`
`250`	`253`	`var uncompressedSize = archive.Read<long>();`
`251`	`254`	`var isEncrypted = archive.ReadFlag();`
`252`		`- var fullPath = archive.ReadString().ToLower()[1..];`
	`255`	`+ var fullPath = archive.ReadString();`
	`256`	`+ if (version < EBackupVersion.PerfectPath) fullPath = fullPath[1..];`
`253`	`257`
`254`	`258`	`AddEntry(fullPath, uncompressedSize, isEncrypted, entries);`
`255`	`259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public class TimeTracker : IDisposable`
`20`	`20`	`public bool IsActive;`
`21`	`21`	`public float ElapsedTime;`
`22`	`22`	`public float MaxElapsedTime;`
`23`		`- public int TimeMultiplier;`
	`23`	`+ public float TimeMultiplier;`
`24`	`24`
`25`	`25`	`public TimeTracker()`
`26`	`26`	`{`
`@@ -51,7 +51,7 @@ public void Reset(bool doMet = true)`
`51`	`51`	`if (doMet)`
`52`	`52`	`{`
`53`	`53`	`MaxElapsedTime = 0.01f;`
`54`		`- TimeMultiplier = 1;`
	`54`	`+ TimeMultiplier = 1f;`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ public override void RenderCollision(Shader shader)`
`153`	`153`
`154`	`154`	`GL.Disable(EnableCap.DepthTest);`
`155`	`155`	`GL.Disable(EnableCap.CullFace);`
`156`		`- GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);`
	`156`	`+ GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Line);`
`157`	`157`	`foreach (var collision in Collisions)`
`158`	`158`	`{`
`159`	`159`	`var boneMatrix = Matrix4x4.Identity;`
`@@ -162,7 +162,7 @@ public override void RenderCollision(Shader shader)`
`162`	`162`
`163`	`163`	`collision.Render(shader, boneMatrix);`
`164`	`164`	`}`
`165`		`- GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);`
	`165`	`+ GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Fill);`
`166`	`166`	`GL.Enable(EnableCap.CullFace);`
`167`	`167`	`GL.Enable(EnableCap.DepthTest);`
`168`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,12 +148,12 @@ public override void RenderCollision(Shader shader)`
`148`	`148`	`base.RenderCollision(shader);`
`149`	`149`
`150`	`150`	`GL.Disable(EnableCap.CullFace);`
`151`		`- GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);`
	`151`	`+ GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Line);`
`152`	`152`	`foreach (var collision in Collisions)`
`153`	`153`	`{`
`154`	`154`	`collision.Render(shader, Matrix4x4.Identity);`
`155`	`155`	`}`
`156`		`- GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);`
	`156`	`+ GL.PolygonMode(TriangleFace.FrontAndBack, PolygonMode.Fill);`
`157`	`157`	`GL.Enable(EnableCap.CullFace);`
`158`	`158`	`}`
`159`	`159`	`}`