Add mesh relation disk (persistent) cache

- Dramatically speeds up reload time for mods, especially those that use a lot of exclusion/inclusion groups where the build time is the worst
- See module comment in MeshRelDiskCache in MeshRelation.fs for more info
- This also locks to FSharp.Core 4.4.3.0 for reasons noted there

Author: jmquigs

FSharp.Core.4.4.3.0/FSharp.Core.dll

@@ -102,7 +102,7 @@
     </ProjectReference>
     <Reference Include="Accessibility" />
     <Reference Include="FSharp.Core">
-      <HintPath>..\packages\FSharp.Core\lib\net45\FSharp.Core.dll</HintPath>
+      <HintPath>..\FSharp.Core.4.4.3.0\FSharp.Core.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.VisualBasic" />
     <Reference Include="MonoGame.Framework">

FSharp.Core.4.4.3.0/FSharp.Core.optdata

@@ -47,6 +47,7 @@ type PreviewHost() =
                             CamPosition = Some(Vec3F(0.f,3.75f,10.0f))
                             MeshReadFlags = { ReadMaterialFile = true; ReverseTransform = false }
                     })
+                Conf.BinCacheDir = ""
             }
             control <- Some(new MeshView.Main.MeshViewControl(conf, x.GraphicsDevice))
         ()

FSharp.Core.4.4.3.0/FSharp.Core.sigdata

@@ -300,6 +300,7 @@ module CoreTypes =
 
     /// Storage for a named Reference object.
     /// The Name of a reference is its base file name (no extension).
+    /// The "DB" prefix naming convention alludes to it being an entity in a "Database" (the mod db).
     type DBReference = {
         Name : string
         Mesh : Lazy<Mesh>
@@ -322,6 +323,9 @@ module CoreTypes =
 
     /// Storage for a named mod.
     /// The Name of a mod is its base file name (no extension).
+    /// The "DB" prefix naming convention alludes to it being an entity in a "Database" (the mod db).
+    /// Do not confuse this type with the `ModDB` type which is the actual database of all the mods and references.
+    /// (A bit of a naming fail there, alas).
     type DBMod = {
         RefName: string option
         Type: ModType

FSharp.Core.4.4.3.0/FSharp.Core.xml

@@ -83,10 +83,14 @@
     <None Include="LoadInFSI.fsx" />
     <None Include="TestFSI.fsx" />
     <Compile Include="Program.fs" />
+    <Content Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="FSharp.Core">
-      <HintPath>..\packages\FSharp.Core\lib\net45\FSharp.Core.dll</HintPath>
+      <HintPath>..\FSharp.Core.4.4.3.0\FSharp.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="FsPickler">
+      <HintPath>..\packages\FsPickler.5.3.2\lib\net45\FsPickler.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
     <Reference Include="SharpDX">

MMLaunch/MMLaunch.fsproj

@@ -68,7 +68,100 @@ module MeshRelation =
         CpuSkinningData: CPUSkinningData option
     }
 
-    type MeshRelation(md:DBMod, ref:DBReference) =
+    /// Utility module to cache mesh relations to disk.  Because these 
+    /// are so inefficient to build (see code below) this dramatically speeds
+    /// up reload times since most mods and references aren't changing 
+    /// from run-to-run.
+    /// 
+    /// This uses FsPickler which is apparently very sensitive to FSharp.Core
+    /// versions - it was failing until I locked everything to use 4.4.3.0 
+    /// (which is what VS2019 wants to use) everywhere.  This is also fixable
+    /// by using a .config file next to the injected exe, which contains a 
+    /// binding redirect, but since that requires dropping extra conf files 
+    /// everywhere I chose not to do that.
+    /// Note this code was mostly generated by LLM (OpenAI GPT 5.2-Thinking)
+    module private MeshRelDiskCache =
+        open System.IO.Compression
+        open MBrace.FsPickler
+
+        let private ser = FsPickler.CreateBinarySerializer()
+        let private cacheVersion = 1
+    
+        type MeshSig = {
+            Path: string
+            Ticks: int64
+            Size: int64
+            ModType: ModType
+            Flags: MeshReadFlags
+        }
+    
+        type Entry = {
+            Version: int
+            Mod: MeshSig
+            Ref: MeshSig
+            VertRels: VertRel[]
+        }
+    
+        let private fileSig (path: string) =
+            let fi = FileInfo(path)
+            fi.LastWriteTimeUtc.Ticks, fi.Length
+    
+        let private mkModSig (md: DBMod) =
+            let t,s = fileSig md.MeshPath
+            { Path = md.MeshPath; Ticks = t; Size = s; ModType = md.Type; Flags = md.MeshReadFlags }
+    
+        let private mkRefSig (r: DBReference) =
+            let t,s = fileSig r.MeshPath
+            { Path = r.MeshPath; Ticks = t; Size = s; ModType = ModType.Reference; Flags = r.MeshReadFlags }
+    
+        let private key (modName: string) (refName: string) =
+            let s = modName.ToLowerInvariant() + "|" + refName.ToLowerInvariant()
+            use sha = System.Security.Cryptography.SHA256.Create()
+            sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(s))
+            |> Seq.map (fun b -> b.ToString("x2"))
+            |> String.concat ""
+    
+        let relPath (cacheDir: string) modName refName =
+            Path.Combine(cacheDir, "MeshRelations", key modName refName + ".bin.gz")
+    
+        let tryLoad (cacheDir: string) (md: DBMod) (r: DBReference) : VertRel[] option =
+            let p = relPath cacheDir md.Name r.Name
+            if not (File.Exists(p)) then None
+            else
+                use fs = File.OpenRead(p)
+                use gz = new GZipStream(fs, CompressionMode.Decompress)
+                let e = ser.Deserialize<Entry>(gz)
+    
+                if e.Version <> cacheVersion then None
+                else
+                    let ms = mkModSig md
+                    let rs = mkRefSig r
+                    if e.Mod = ms && e.Ref = rs then Some e.VertRels else None
+    
+        let save (cacheDir: string) (md: DBMod) (r: DBReference) (vrs: VertRel[]) =
+            let dir = Path.Combine(cacheDir, "MeshRelations")
+            Directory.CreateDirectory(dir) |> ignore
+            let p = relPath cacheDir md.Name r.Name
+            let tmp = p + ".tmp"
+
+            log.Info "[meshrelcache]: creating bincache entry: %A for mod=%A ref=%A" tmp md.Name r.Name
+    
+            let e =
+                { 
+                    Entry.Version = cacheVersion
+                    Mod = mkModSig md
+                    Ref = mkRefSig r
+                    VertRels = vrs 
+                }
+    
+            use fs = File.Create(tmp)
+            use gz = new GZipStream(fs, CompressionMode.Compress)
+            ser.Serialize(gz, e)
+    
+            if File.Exists(p) then File.Delete(p)
+            File.Move(tmp, p)
+    
+    type MeshRelation(md:DBMod, ref:DBReference, binCacheDir:string) =
         let verifyAndGet(name:string) (mo:Lazy<Mesh> option) =
             match mo with
             | None -> failwithf "cannot build vertrel for mod/ref with no mesh: %A" name
@@ -273,16 +366,48 @@ module MeshRelation =
 
             modVertRels
 
-        let buildIt() = 
-            //log.Info "Starting build of meshrelation for mod: %A" md.Name
-            modMesh <- Some ((verifyAndGet md.Name md.Mesh).Force())
-            refMesh <- Some ((ref.Mesh.Force()))
+        let buildIt() =
+            let binCacheDir = binCacheDir.Trim()
+            let useBinCache = 
+                if binCacheDir = "" then false
+                else 
+                    if not (Directory.Exists binCacheDir) then Directory.CreateDirectory binCacheDir |> ignore
+                    true
+
+            let loadFresh() = 
+                let sw = new Util.StopwatchTracker("MeshRel:" + md.Name + "/" + ref.Name)
+                let vertRels = buildVertRels()
+                log.Info "built mesh relation from mod '%s' to ref '%s'" md.Name ref.Name
+                sw.StopAndPrint()
+
+                vertRels
 
-            let sw = new Util.StopwatchTracker("MeshRel:" + md.Name + "/" + ref.Name)
-            let vertRels = buildVertRels()
-            log.Info "built mesh relation from mod '%s' to ref '%s'" md.Name ref.Name
-            sw.StopAndPrint()
-            vertRels
+            modMesh <- Some ((verifyAndGet md.Name md.Mesh).Force())
+            refMesh <- Some (ref.Mesh.Force())
+                
+            let cacheVROpt = 
+                if useBinCache then 
+                    try 
+                        MeshRelDiskCache.tryLoad binCacheDir md ref 
+                    with e -> 
+                        log.Error "%A" e
+                        None
+                else None
+
+            match cacheVROpt with
+            | Some cachedVertRels ->
+                log.Info "[meshrelcache]: loaded mesh relation from cache for mod '%s' to ref '%s' (cache file: %A)" md.Name ref.Name 
+                    (MeshRelDiskCache.relPath binCacheDir md.Name ref.Name )
+                cachedVertRels
+            | None ->
+                let vertRels = loadFresh()
+
+                if useBinCache then
+                    try 
+                        MeshRelDiskCache.save binCacheDir md ref vertRels
+                    with e -> 
+                        log.Error "%A" e        
+                vertRels
 
         let vertRels = lazy (buildIt())
 

MMLaunch/PreviewHost.fs

@@ -698,7 +698,7 @@ module ModDB =
 
                     let newMeshRel() =
                         nBuilt <- nBuilt + 1
-                        new MeshRelation(dbmod, Option.get dbmod.Ref)
+                        new MeshRelation(dbmod, Option.get dbmod.Ref, conf.BinCacheDir)
 
                     // if both of the meshes are unchanged (or if loading them would use a cache entry, meaning they are unchanged)
                     // we can reuse the mesh relation.  the case where the mesh relation exists but the meshes aren't loaded, yet they are cached,