Move snap profile into core types, expose it in interop

- When a mod has it, the values are now loaded and passed through to interop
- Not yet used by native code but will be soon to inform tangent space handling
- Add some additional checks for interop structure sizes on init - native code now passes the size of (some of) its structs, and managed code will now fail if the mod struct size isn't what it expects

Author: jmquigs

MMLaunch/ModUtil.fs

@@ -200,7 +200,7 @@ module ModUtil =
         Ref: string
         ModType: string // subtype of the mod (gpureplacement, etc)
         MeshPath: string
-        Profile: ModelMod.SnapshotProfile.Profile
+        Profile: ModelMod.CoreTypes.SnapProfile
     }
 
     let getOutputPath modRoot modName = Path.GetFullPath(Path.Combine(modRoot, modName))

MMManaged/CoreTypes.fs

@@ -16,6 +16,7 @@
 
 namespace ModelMod
 
+open System
 open SharpDX.Direct3D9
 
 // Shorthand type defs
@@ -218,6 +219,41 @@ module CoreTypes =
         ReverseTransform = true
     }
 
+    /// A snapshot profile controls what types of data transformations
+    /// (typically vertex position and uv coordinates) that are applied by the snapshotter.  These are typically used to
+    /// position the snapshotted mesh in a location that is convenient for use in a 3D tool (therefore, different tools may
+    /// need different profiles for the same game).  The transforms are automatically reversed on load so that the data is
+    /// in the correct space for the game.
+    /// More recently the profile has been extended to specify how certain parts of the mesh data (e.g tangent space vectors)
+    /// should be interpreted, both during snapshot and mod load.
+    type SnapProfile() =
+        let mutable name:string = "";
+        let mutable posX:ResizeArray<String> = new ResizeArray<string>();
+        let mutable uvX:ResizeArray<String> = new ResizeArray<string>();
+        let mutable flipTangent:bool = false;
+        let mutable vecEncoding:string = "";
+
+        static member Create(name,posX,uvX,flipTangent,vecEncoding:string):SnapProfile = 
+            let p = new SnapProfile()
+            p.Name <- name
+            p.PosXForm <- posX 
+            p.UVXForm <- uvX
+            p.FlipTang <- flipTangent
+            p.VecEncoding <- vecEncoding
+            p
+
+        member x.Name with get() = name and set v = name <- v
+        member x.PosXForm with get() = posX and set v = posX <- v 
+        member x.UVXForm with get() = uvX and set v = uvX <- v
+        member x.FlipTang with get() = flipTangent and set v = flipTangent <- v
+        member x.VecEncoding with get() = vecEncoding and set v = vecEncoding <- v
+
+        member x.IsPackedVec() = vecEncoding.Trim().ToLowerInvariant() = "packed"
+        member x.IsOctaVec() = vecEncoding.Trim().ToLowerInvariant() = "octa"
+
+        override x.ToString() =
+            sprintf "[SnapshotProfile: %s; pos: %A; uv: %A, fliptangent: %A, vecencoding: %A]" name posX uvX flipTangent vecEncoding
+
     /// Basic storage for everything that we consider to be "mesh data".  This is intentionally pretty close to the
     /// renderer level; i.e. we don't have fields like "NormalMap" because the texture stage used for will vary
     /// across games or even within the same game.  Generally if you want to customize a texture its up to you to make
@@ -303,6 +339,8 @@ module CoreTypes =
         /// Setting this to false disables the update (and thus the fixed coordinate axis will be used).  Setting this to true always
         /// regenerates even if tangent space is globally disabled in the game profile.  When left unspecified the global default is used.
         UpdateTangentSpace: bool option
+        /// Snapshot profile; optional since many older mods will not have this.
+        Profile: SnapProfile option
     }
 
     /// Union Parent type for the yaml objects.

MMManaged/Interop.fs

@@ -56,8 +56,8 @@ type InteropInitStruct =
 /// loading the assembly.
 type Main() =
     /// The native code version that this managed code is compatible with.  This should be bumped each
-    /// time the interop interface (e.g struct layouts) change.
-    static let NativeCodeVersion = 3
+    /// time the interop interface (e.g struct layouts) change.  (also see NATIVE_CODE_VERSION in rust code)
+    static let NativeCodeVersion = 4
 
     static let mutable oninitialized: ((MMNative.ManagedCallbacks * uint64) -> int) option = None
     static let mutable log:Logging.ILog option = None
@@ -179,6 +179,8 @@ type Main() =
 
     static member Main(args:string) =
         let mutable ret = InteropTypes.Assplosion
+        let mutable loginit = false
+
         try
             // args are | delimited, first arg is nativeGlobalState handle (opaque to managed code)
             // second is load context (i.e is the native code in d3d9.dll or mm_native.dll)
@@ -203,17 +205,40 @@ type Main() =
             ret <- Main.IdentifyInLog()
             if ret <> 0 then
                 failwithf "Log init failed: %A" ret
+            loginit <- true
+
+            let checkSizeMatch (argstr:string) (paramstr:string) (mtype:System.Type) = 
+                if argstr.StartsWith(paramstr) then 
+
+                    let arg = argstr.Split([|paramstr|], StringSplitOptions.RemoveEmptyEntries)
+                    let size = arg.[0] |> int 
+                    let esize = Marshal.SizeOf(mtype)
+                    if size <> esize then 
+                        failwithf "Managed struct size of %A does not match matches native code expected: %A, got: %A" argstr esize size
+                    else 
+                        Main.Log.Info "  Native/Managed: struct size ok: %A" argstr
+
+            if args.Length > 2 then 
+                let args = args |> Array.skip 3
+                for arg in args do 
+                    let arg = arg.ToLowerInvariant()
+                    checkSizeMatch arg ("mod_structsize=") (typeof<InteropTypes.ModData>)
+                    checkSizeMatch arg ("mod_snapprofile_structsize=") (typeof<InteropTypes.ModSnapProfile>)
 
             if not versionChecked then
-                Main.Log.Warn "Native code did not pass a version, a crash is possible."
+                Main.Log.Warn "Native code did not provide its version, a crash is possible."
 
             ret <- Main.InitCallbacks(nativeGlobalState,context)
             ret
         with
             | e ->
-                // print it, but it will likely go nowhere
-                printfn "An exception occured."
-                printfn "Exception: %A" e
+                if loginit then 
+                    Main.Log.Error "%A" e
+                else 
+                    // print it, but it will likely go nowhere
+                    printfn "An exception occured."
+                    printfn "Exception: %A" e
+
                 if ret = 0 then
                     InteropTypes.Assplosion
                 else

MMManaged/InteropTypes.fs

@@ -49,6 +49,69 @@ module InteropTypes =
         val mutable Data:System.IntPtr
         val mutable Size:int32
 
+    let MaxModSnapProfileXFormLen = 8
+
+    [<Struct; StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)>]
+    type ModSnapProfileXFormString = {
+        [<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)>]
+        Text : string    
+    }
+
+    let makeXFormString (s:string) = 
+        let maxChars = 255
+        let trimmed =
+            if System.String.IsNullOrEmpty s then ""
+            elif s.Length > maxChars then s.Substring(0, maxChars)
+            else s
+        { Text = trimmed }
+
+    /// The profile that was used to snapshot the mod.  Manage code will typically reverse Pos and UV transforms during mod load,
+    /// but unmanaged code can handle other details such as generating tangent space or packing vectors in correct format.
+    /// Not all mods will have this, so unmanaged code should check the "Valid" field to see if it is populated.
+    [<Struct; StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)>]
+    type ModSnapProfile = {
+        /// Whether the fields have been set on this profile, unmanaged code uses this to determine 
+        /// whether to use it or not (essentially makes it a implicit "option" type)
+        [<MarshalAs(UnmanagedType.U1)>]
+        Valid: bool
+
+        /// Name of this profile
+        [<MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)>]
+        Name: string
+    
+        /// Number of position transforms
+        PosXLength: int
+        [<MarshalAs(UnmanagedType.ByValArray, SizeConst=8)>]
+        /// Position transforms
+        PosX: ModSnapProfileXFormString[]
+    
+        /// Number of UV transforms
+        UVXLength: int
+        [<MarshalAs(UnmanagedType.ByValArray, SizeConst=8)>]
+        /// UV transforms
+        UVX: ModSnapProfileXFormString[]
+
+        /// Whether to flip tangents
+        [<MarshalAs(UnmanagedType.U1)>]
+        FlipTangent: bool
+    
+        /// How vectors should be encoded in d3d data
+        [<MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)>]
+        VecEncoding: string
+    }
+
+    // Example empty value for InteropProfile
+    let EmptyModSnapProfile = {
+        Valid = false
+        Name = ""
+        PosXLength = 0
+        PosX = Array.create MaxModSnapProfileXFormLen (makeXFormString "")
+        UVXLength = 0
+        UVX = Array.create MaxModSnapProfileXFormLen (makeXFormString "")
+        FlipTangent = false
+        VecEncoding = ""
+    }
+
     /// Various mod metadata.  Derived from Mesh, DBReference, and DBMod types.
     [<StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)>]
     type ModData = {
@@ -79,6 +142,7 @@ module InteropTypes =
         ParentModName: string
         [<MarshalAs(UnmanagedType.ByValTStr, SizeConst=8192)>]
         PixelShaderPath: string
+        SnapProfile: ModSnapProfile
     }
 
     /// Default value.  Also used as an error return value, since we don't throw exceptions accross interop.
@@ -101,6 +165,7 @@ module InteropTypes =
         ParentModName = ""
         PixelShaderPath = ""
         UpdateTangentSpace = -1
+        SnapProfile = EmptyModSnapProfile
     }
 
     [<StructLayout(LayoutKind.Sequential, Pack=4)>]

MMManaged/MMManaged.fsproj

@@ -72,9 +72,9 @@
     <Compile Include="StartConf.fs" />
     <Compile Include="MeshRelation.fs" />
     <Compile Include="MemoryCache.fs" />
+    <Compile Include="SnapshotProfile.fs" />
     <Compile Include="ModDB.fs" />
     <Compile Include="DataEncoding.fs" />
-    <Compile Include="SnapshotProfile.fs" />
     <Compile Include="State.fs" />
     <Compile Include="ModDBInterop.fs" />
     <Compile Include="Snapshot.fs" />

MMManaged/ModDB.fs

@@ -31,6 +31,7 @@ open StartConf
 open CoreTypes
 open InteropTypes
 open VertexTypes
+open SnapshotProfile
 
 /// Contains the "Mod Database"; functions for reading yaml, mmobj, and other files and storing them in memory.
 module ModDB =
@@ -227,6 +228,12 @@ module ModDB =
 
         let computeTS = node |> Yaml.getOptionalValue "UpdateTangentSpace" |> Yaml.toOptionalBool
 
+        // has a profile?
+        let profile = 
+            match node |> Yaml.getOptionalValue "Profile" |> Yaml.toOptionalMapping with 
+            | Some(profile) -> Some(loadSingleProfile "" profile)
+            | None -> None
+
         let md = {
             DBMod.RefName = refName
             Ref = None // defer ref resolution until all files have been loaded - avoids forward ref problems
@@ -237,6 +244,7 @@ module ModDB =
             PixelShader = pixelShader
             ParentModName = parentModName
             UpdateTangentSpace = computeTS
+            Profile = profile
         }
 
         let numOverrideTextures =
@@ -246,7 +254,7 @@ module ModDB =
                 let oneIfNotEmpty (s:string) = if s.Trim() <> "" then 1 else 0
                 oneIfNotEmpty mesh.Tex0Path + oneIfNotEmpty mesh.Tex1Path + oneIfNotEmpty mesh.Tex2Path + oneIfNotEmpty mesh.Tex3Path
 
-        log().Info "Mod: %A: type: %A, ref: %A, weightmode: %A, override textures: %d" modName modType refName weightMode numOverrideTextures
+        log().Info "Mod: %A: type: %A, ref: %A, weightmode: %A, override textures: %d: profile: %A" modName modType refName weightMode numOverrideTextures profile
         Mod(md)
 
     /// Read an SDX vertex element from the specified stream.

MMManaged/ModDBInterop.fs

@@ -252,6 +252,11 @@ module ModDBInterop =
             | None -> -1
             | Some(upd) -> if upd then 1 else 0
 
+        let profile = 
+            match meshrel.DBMod.Profile with 
+            | None -> EmptyModSnapProfile
+            | Some(p) -> SnapshotProfile.toInteropStruct p
+
         {
             InteropTypes.ModData.ModType = modType
             PrimType = primType
@@ -271,6 +276,7 @@ module ModDBInterop =
             ModName = mname
             ParentModName = parentModName
             UpdateTangentSpace = updateTS
+            SnapProfile = profile
         }
 
     /// Get the mod data at the specified index.  If index is out of range, returns InteropTypes.EmptyModData.

MMManaged/Snapshot.fs

@@ -119,7 +119,7 @@ module Snapshot =
     }
 
     type SnapMeta() = 
-        let mutable profile:SnapshotProfile.Profile = SnapshotProfile.EmptyProfile
+        let mutable profile:CoreTypes.SnapProfile = SnapshotProfile.EmptyProfile
         let mutable context:string = ""
 
         static member Create(profile):SnapMeta = 
@@ -133,7 +133,7 @@ module Snapshot =
 
     /// Reads a vertex element.  Uses the read output functions to pipe the data to an appropriate handler
     /// function, depending on the type.
-    let private readElement (snapProfile:SnapshotProfile.Profile) (fns:ReadOutputFunctions) (ignoreFns:ReadOutputFunctions) reader (el:VertexTypes.MMVertexElement) =
+    let private readElement (snapProfile:CoreTypes.SnapProfile) (fns:ReadOutputFunctions) (ignoreFns:ReadOutputFunctions) reader (el:VertexTypes.MMVertexElement) =
         let fns =
             if el.SemanticIndex = 0 then
                 fns