Parse and use model-level render flag in export logic

PassiveModding · PassiveModding · commit 1f30f184a011 · 2026-03-09T18:20:14.000+11:00
diff --git a/Meddle/Meddle.Plugin/Configuration.cs b/Meddle/Meddle.Plugin/Configuration.cs
@@ -53,7 +53,11 @@ public class ExportConfiguration
         
         [Obsolete("Use PoseMode instead", true)]
         public bool ExportPose { get; set; } = true;
+        
+        [Obsolete("Use ApplyVisibilityFlags instead", true)]
         public bool RemoveAttributeDisabledSubmeshes { get; set; } = true;
+        
+        public bool ApplyVisibilityFlags { get; set; } = true;
         public bool SkipHiddenBgParts { get; set; }
         public bool UseDeformer { get; set; } = true;
         
@@ -78,7 +82,8 @@ public ExportConfiguration Clone()
                 // ExportPose = ExportPose,
                 // TextureMode = TextureMode,
                 PoseMode = PoseMode,
-                RemoveAttributeDisabledSubmeshes = RemoveAttributeDisabledSubmeshes,
+                // RemoveAttributeDisabledSubmeshes = RemoveAttributeDisabledSubmeshes,
+                ApplyVisibilityFlags = ApplyVisibilityFlags,
                 SkipHiddenBgParts = SkipHiddenBgParts,
                 // RootAttachHandling = RootAttachHandling
                 UseDeformer = UseDeformer,
@@ -90,9 +95,10 @@ public ExportConfiguration Clone()
 
         public void SetDefaultCloneOptions()
         {
-            RemoveAttributeDisabledSubmeshes = true;
+            // RemoveAttributeDisabledSubmeshes = true;
             SkipHiddenBgParts = true;
             UseDeformer = true;
+            ApplyVisibilityFlags = true;
         }
         
         public void Apply(ExportConfiguration other)
@@ -102,7 +108,8 @@ public void Apply(ExportConfiguration other)
             // ExportPose = other.ExportPose;
             // TextureMode = other.TextureMode;
             PoseMode = other.PoseMode;
-            RemoveAttributeDisabledSubmeshes = other.RemoveAttributeDisabledSubmeshes;
+            // RemoveAttributeDisabledSubmeshes = other.RemoveAttributeDisabledSubmeshes;
+            ApplyVisibilityFlags = other.ApplyVisibilityFlags;
             SkipHiddenBgParts = other.SkipHiddenBgParts;
             // RootAttachHandling = other.RootAttachHandling;
             UseDeformer = other.UseDeformer;
diff --git a/Meddle/Meddle.Plugin/Models/Composer/CharacterComposer.cs b/Meddle/Meddle.Plugin/Models/Composer/CharacterComposer.cs
@@ -47,6 +47,12 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S
             return;
         }
         
+        if (!m.Enabled && exportConfig.ApplyVisibilityFlags)
+        {
+            Plugin.Logger.LogDebug("Skipping disabled model {ModelPath}", m.Path.GamePath);
+            return;
+        }
+        
         var mdlFile = composerCache.GetMdlFile(m.Path.FullPath);
         Plugin.Logger.LogInformation("Loaded model {modelPath}", m.Path.FullPath);
         var materialBuilders = new MaterialBuilder[m.Materials.Length];
@@ -122,13 +128,13 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S
 
         var enabledAttributes = Model.GetEnabledValues(model.EnabledAttributeMask, model.AttributeMasks).ToArray();
         var meshes = ModelBuilder.BuildMeshes(model, materialBuilders, skinningContext.Bones, deform, exportConfig.CreateMeshBuilderOptions());
-        foreach (var mesh in meshes)
+        foreach (var meshExport in meshes)
         {
             var extrasDict = new Dictionary<string, string>
             {
                 {"modelGamePath", m.Path.GamePath},
                 {"modelFullPath", m.Path.FullPath},
-                {"meshShapes", mesh.Shapes != null ? string.Join(",", mesh.Shapes) : ""},
+                {"meshShapes", meshExport.Shapes != null ? string.Join(",", meshExport.Shapes) : ""},
                 {"modelEnabledAttributes", string.Join(",", enabledAttributes)},
                 {"modelAttributes", string.Join(",", model.AttributeMasks.Select(x => x.name))},
                 {"nodeType", "CharacterMesh"}
@@ -150,7 +156,7 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S
             }
 
             // for shape keys to work, mesh.Mesh.Extras already has an object with a field 'targetNames' which names all the shape keys. need to preserve that.
-            var extras = mesh.Mesh.Extras?.AsObject();
+            var extras = meshExport.Mesh.Extras?.AsObject();
             if (extras != null)
             {
                 foreach (var kvp in extrasDict)
@@ -161,38 +167,38 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S
                     }
                 }
                 
-                mesh.Mesh.Extras = extras;
+                meshExport.Mesh.Extras = extras;
             }
             else
             {
-                mesh.Mesh.Extras = JsonNode.Parse(JsonSerializer.Serialize(extrasDict, MaterialComposer.JsonOptions));
+                meshExport.Mesh.Extras = JsonNode.Parse(JsonSerializer.Serialize(extrasDict, MaterialComposer.JsonOptions));
             }
             
             InstanceBuilder instance;
             if (skinningContext.Bones.Count > 0)
             {
-                instance = scene.AddSkinnedMesh(mesh.Mesh, skinningContext.Transform, skinningContext.Bones.Cast<NodeBuilder>().ToArray());
+                instance = scene.AddSkinnedMesh(meshExport.Mesh, skinningContext.Transform, skinningContext.Bones.Cast<NodeBuilder>().ToArray());
             }
             else
             {
-                instance = scene.AddRigidMesh(mesh.Mesh, skinningContext.Transform);
+                instance = scene.AddRigidMesh(meshExport.Mesh, skinningContext.Transform);
             }
 
-            if (model.Shapes.Count != 0 && mesh.Shapes != null)
+            if (model.Shapes.Count != 0 && meshExport.Shapes != null)
             {
                 // This will set the morphing value to 1 if the shape is enabled, 0 if not
                 var enabledShapes = Model.GetEnabledValues(model.EnabledShapeMask, model.ShapeMasks)
                                          .ToArray();
                 var shapes = model.Shapes
-                                  .Where(x => mesh.Shapes.Contains(x.Name))
+                                  .Where(x => meshExport.Shapes.Contains(x.Name))
                                   .Select(x => (x, enabledShapes.Contains(x.Name)));
                 instance.Content.UseMorphing().SetValue(shapes.Select(x => x.Item2 ? 1f : 0).ToArray());
             }
             
-            if (mesh.Submesh != null)
+            if (meshExport.Submesh != null && exportConfig.ApplyVisibilityFlags)
             {
                 // Remove subMeshes that are not enabled
-                if (!mesh.Submesh.Attributes.All(enabledAttributes.Contains) && exportConfig.RemoveAttributeDisabledSubmeshes)
+                if (!meshExport.Submesh.Attributes.All(x => enabledAttributes.Contains(x)))
                 {
                     instance.Remove();
                 }
diff --git a/Meddle/Meddle.Plugin/Models/Layout/ParsedInstance.cs b/Meddle/Meddle.Plugin/Models/Layout/ParsedInstance.cs
@@ -481,9 +481,10 @@ public string GetHash()
     }
 }
 
-public class ParsedModelInfo(string path, string pathFromCharacter, DeformerCachedStruct? deformer, Model.ShapeAttributeGroup? shapeAttributeGroup, ParsedMaterialInfo?[] materials, Stain? stain0, Stain? stain1) 
+public class ParsedModelInfo(string path, string pathFromCharacter, bool enabled, DeformerCachedStruct? deformer, Model.ShapeAttributeGroup? shapeAttributeGroup, ParsedMaterialInfo?[] materials, Stain? stain0, Stain? stain1) 
 {
     public HandleString Path { get; } = new() { FullPath = path, GamePath = pathFromCharacter };
+    public bool Enabled { get; } = enabled;
     public ParsedStain? Stain0 { get; } = stain0;
     public ParsedStain? Stain1 { get; } = stain1;
     public DeformerCachedStruct? Deformer { get; } = deformer;
diff --git a/Meddle/Meddle.Plugin/Models/Structs/ModelResourceHandle.cs b/Meddle/Meddle.Plugin/Models/Structs/ModelResourceHandle.cs
@@ -13,6 +13,15 @@ public unsafe struct MeddleModelResourceHandle
     public ModelResourceHandleData GetData() => new(Base->ModelData);
 } 
 
+[StructLayout(LayoutKind.Explicit, Size = 0x158)]
+public unsafe struct MeddleModel
+{
+    [FieldOffset(0x0)] public FFXIVClientStructs.FFXIV.Client.Graphics.Render.Model* Base;
+    [FieldOffset(0x28)] public uint Flags; // bit 0: body visible, bit 1: attributes dirty, bit 2: shapes dirty
+    
+    public bool BodyVisible => (Flags & 1) != 0;
+} 
+
 
 public readonly struct ModelResourceHandleData
 {
diff --git a/Meddle/Meddle.Plugin/Services/ResolverService.cs b/Meddle/Meddle.Plugin/Services/ResolverService.cs
@@ -189,7 +189,7 @@ private void ResolveInstance(ParsedInstance instance)
             materials.Add(materialInfo);
         }
 
-        var modelInfo = new ParsedModelInfo(path, path, null, null, materials.ToArray(), null, null);
+        var modelInfo = new ParsedModelInfo(path, path, true, null, null, materials.ToArray(), null, null);
         return modelInfo;
     }
 
diff --git a/Meddle/Meddle.Plugin/UI/LiveCharacterTab.cs b/Meddle/Meddle.Plugin/UI/LiveCharacterTab.cs
@@ -14,6 +14,7 @@
 using Meddle.Plugin.Models;
 using Meddle.Plugin.Models.Composer;
 using Meddle.Plugin.Models.Layout;
+using Meddle.Plugin.Models.Structs;
 using Meddle.Plugin.Services;
 using Meddle.Plugin.UI.Layout;
 using Meddle.Plugin.UI.Windows;
@@ -493,6 +494,11 @@ private void DrawModel(Pointer<CharacterBase> cPtr, Pointer<CSModel> mPtr)
             header += $"[{(HumanModelSlotIndex)model->SlotIndex}]";
         }
         header += $" {modelName}";
+        bool modelEnabled = ((MeddleModel*)model)->BodyVisible;
+        if (!modelEnabled)
+        {
+            header += " (Hidden)";
+        }
         if (ImGui.CollapsingHeader(header))
         {
             UiUtil.Text($"Game File Name: {modelName}", modelName);
@@ -536,7 +542,8 @@ private void DrawModel(Pointer<CharacterBase> cPtr, Pointer<CSModel> mPtr)
             {
                 ImGui.Text("No deformer info found");
             }
-
+            ImGui.Text($"Model Enabled: {modelEnabled}");
+            
             var modelShapeAttributes = StructExtensions.ParseModelShapeAttributes(model);
             DrawShapeAttributeTable(modelShapeAttributes);
 
diff --git a/Meddle/Meddle.Plugin/Utils/ParseMaterialUtil.cs b/Meddle/Meddle.Plugin/Utils/ParseMaterialUtil.cs
@@ -134,6 +134,7 @@ public static class ParseMaterialUtil
             var modelInfo = new ParsedModelInfo(
                 model->ModelResourceHandle->FileName.ParseString(), 
                 characterBase->ResolveMdlPath(model->SlotIndex), 
+                ((MeddleModel*)model)->BodyVisible,
                 deform, 
                 StructExtensions.ParseModelShapeAttributes(model), 
                 materials.ToArray(), 
diff --git a/Meddle/Meddle.Plugin/Utils/UIUtil.cs b/Meddle/Meddle.Plugin/Utils/UIUtil.cs
@@ -172,16 +172,27 @@ public static bool DrawExportConfig(Configuration.ExportConfiguration exportConf
 
         if (flags.HasFlag(ExportConfigDrawFlags.ShowSubmeshOptions))
         {
-            var removeAttributeDisabledSubmeshes = exportConfiguration.RemoveAttributeDisabledSubmeshes;
-            if (ImGui.Checkbox("Remove unused character features", ref removeAttributeDisabledSubmeshes))
+            // var removeAttributeDisabledSubmeshes = exportConfiguration.RemoveAttributeDisabledSubmeshes;
+            // if (ImGui.Checkbox("Remove unused character features", ref removeAttributeDisabledSubmeshes))
+            // {
+            //     exportConfiguration.RemoveAttributeDisabledSubmeshes = removeAttributeDisabledSubmeshes;
+            //     changed = true;
+            // }
+            //
+            // ImGui.SameLine();
+            // HintCircle("Certain character features can be toggled on and off in the character creator,\n" +
+            //            "this will make sure the export only includes the features that are currently enabled.");
+            
+            var applyEqpFlags = exportConfiguration.ApplyVisibilityFlags;
+            if (ImGui.Checkbox("Apply Visibility Flags", ref applyEqpFlags))
             {
-                exportConfiguration.RemoveAttributeDisabledSubmeshes = removeAttributeDisabledSubmeshes;
+                exportConfiguration.ApplyVisibilityFlags = applyEqpFlags;
                 changed = true;
             }
-
+            
             ImGui.SameLine();
-            HintCircle("Certain character features can be toggled on and off in the character creator,\n" +
-                       "this will make sure the export only includes the features that are currently enabled.");
+            HintCircle("If enabled, the export will apply visibility flags based on EQP manipulations and certain in-game toggles (such as additional character features)\n" +
+                       "This will make sure the export only includes the models/submeshes that are currently visible on the character.");
         }
         
         if (flags.HasFlag(ExportConfigDrawFlags.ShowTerrainOptions))

Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,12 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S`
`47`	`47`	`return;`
`48`	`48`	`}`
`49`	`49`
	`50`	`+ if (!m.Enabled && exportConfig.ApplyVisibilityFlags)`
	`51`	`+ {`
	`52`	`+ Plugin.Logger.LogDebug("Skipping disabled model {ModelPath}", m.Path.GamePath);`
	`53`	`+ return;`
	`54`	`+ }`
	`55`	`+`
`50`	`56`	`var mdlFile = composerCache.GetMdlFile(m.Path.FullPath);`
`51`	`57`	`Plugin.Logger.LogInformation("Loaded model {modelPath}", m.Path.FullPath);`
`52`	`58`	`var materialBuilders = new MaterialBuilder[m.Materials.Length];`
`@@ -122,13 +128,13 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S`
`122`	`128`
`123`	`129`	`var enabledAttributes = Model.GetEnabledValues(model.EnabledAttributeMask, model.AttributeMasks).ToArray();`
`124`	`130`	`var meshes = ModelBuilder.BuildMeshes(model, materialBuilders, skinningContext.Bones, deform, exportConfig.CreateMeshBuilderOptions());`
`125`		`- foreach (var mesh in meshes)`
	`131`	`+ foreach (var meshExport in meshes)`
`126`	`132`	`{`
`127`	`133`	`var extrasDict = new Dictionary<string, string>`
`128`	`134`	`{`
`129`	`135`	`{"modelGamePath", m.Path.GamePath},`
`130`	`136`	`{"modelFullPath", m.Path.FullPath},`
`131`		`- {"meshShapes", mesh.Shapes != null ? string.Join(",", mesh.Shapes) : ""},`
	`137`	`+ {"meshShapes", meshExport.Shapes != null ? string.Join(",", meshExport.Shapes) : ""},`
`132`	`138`	`{"modelEnabledAttributes", string.Join(",", enabledAttributes)},`
`133`	`139`	`{"modelAttributes", string.Join(",", model.AttributeMasks.Select(x => x.name))},`
`134`	`140`	`{"nodeType", "CharacterMesh"}`
`@@ -150,7 +156,7 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S`
`150`	`156`	`}`
`151`	`157`
`152`	`158`	`// for shape keys to work, mesh.Mesh.Extras already has an object with a field 'targetNames' which names all the shape keys. need to preserve that.`
`153`		`- var extras = mesh.Mesh.Extras?.AsObject();`
	`159`	`+ var extras = meshExport.Mesh.Extras?.AsObject();`
`154`	`160`	`if (extras != null)`
`155`	`161`	`{`
`156`	`162`	`foreach (var kvp in extrasDict)`
`@@ -161,38 +167,38 @@ private void HandleModel(ParsedCharacterInfo characterInfo, ParsedModelInfo m, S`
`161`	`167`	`}`
`162`	`168`	`}`
`163`	`169`
`164`		`- mesh.Mesh.Extras = extras;`
	`170`	`+ meshExport.Mesh.Extras = extras;`
`165`	`171`	`}`
`166`	`172`	`else`
`167`	`173`	`{`
`168`		`- mesh.Mesh.Extras = JsonNode.Parse(JsonSerializer.Serialize(extrasDict, MaterialComposer.JsonOptions));`
	`174`	`+ meshExport.Mesh.Extras = JsonNode.Parse(JsonSerializer.Serialize(extrasDict, MaterialComposer.JsonOptions));`
`169`	`175`	`}`
`170`	`176`
`171`	`177`	`InstanceBuilder instance;`
`172`	`178`	`if (skinningContext.Bones.Count > 0)`
`173`	`179`	`{`
`174`		`- instance = scene.AddSkinnedMesh(mesh.Mesh, skinningContext.Transform, skinningContext.Bones.Cast<NodeBuilder>().ToArray());`
	`180`	`+ instance = scene.AddSkinnedMesh(meshExport.Mesh, skinningContext.Transform, skinningContext.Bones.Cast<NodeBuilder>().ToArray());`
`175`	`181`	`}`
`176`	`182`	`else`
`177`	`183`	`{`
`178`		`- instance = scene.AddRigidMesh(mesh.Mesh, skinningContext.Transform);`
	`184`	`+ instance = scene.AddRigidMesh(meshExport.Mesh, skinningContext.Transform);`
`179`	`185`	`}`
`180`	`186`
`181`		`- if (model.Shapes.Count != 0 && mesh.Shapes != null)`
	`187`	`+ if (model.Shapes.Count != 0 && meshExport.Shapes != null)`
`182`	`188`	`{`
`183`	`189`	`// This will set the morphing value to 1 if the shape is enabled, 0 if not`
`184`	`190`	`var enabledShapes = Model.GetEnabledValues(model.EnabledShapeMask, model.ShapeMasks)`
`185`	`191`	`.ToArray();`
`186`	`192`	`var shapes = model.Shapes`
`187`		`- .Where(x => mesh.Shapes.Contains(x.Name))`
	`193`	`+ .Where(x => meshExport.Shapes.Contains(x.Name))`
`188`	`194`	`.Select(x => (x, enabledShapes.Contains(x.Name)));`
`189`	`195`	`instance.Content.UseMorphing().SetValue(shapes.Select(x => x.Item2 ? 1f : 0).ToArray());`
`190`	`196`	`}`
`191`	`197`
`192`		`- if (mesh.Submesh != null)`
	`198`	`+ if (meshExport.Submesh != null && exportConfig.ApplyVisibilityFlags)`
`193`	`199`	`{`
`194`	`200`	`// Remove subMeshes that are not enabled`
`195`		`- if (!mesh.Submesh.Attributes.All(enabledAttributes.Contains) && exportConfig.RemoveAttributeDisabledSubmeshes)`
	`201`	`+ if (!meshExport.Submesh.Attributes.All(x => enabledAttributes.Contains(x)))`
`196`	`202`	`{`
`197`	`203`	`instance.Remove();`
`198`	`204`	`}`
Original file line number	Diff line number	Diff line change
`@@ -481,9 +481,10 @@ public string GetHash()`
`481`	`481`	`}`
`482`	`482`	`}`
`483`	`483`
`484`		`-public class ParsedModelInfo(string path, string pathFromCharacter, DeformerCachedStruct? deformer, Model.ShapeAttributeGroup? shapeAttributeGroup, ParsedMaterialInfo?[] materials, Stain? stain0, Stain? stain1)`
	`484`	`+public class ParsedModelInfo(string path, string pathFromCharacter, bool enabled, DeformerCachedStruct? deformer, Model.ShapeAttributeGroup? shapeAttributeGroup, ParsedMaterialInfo?[] materials, Stain? stain0, Stain? stain1)`
`485`	`485`	`{`
`486`	`486`	`public HandleString Path { get; } = new() { FullPath = path, GamePath = pathFromCharacter };`
	`487`	`+ public bool Enabled { get; } = enabled;`
`487`	`488`	`public ParsedStain? Stain0 { get; } = stain0;`
`488`	`489`	`public ParsedStain? Stain1 { get; } = stain1;`
`489`	`490`	`public DeformerCachedStruct? Deformer { get; } = deformer;`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,15 @@ public unsafe struct MeddleModelResourceHandle`
`13`	`13`	`public ModelResourceHandleData GetData() => new(Base->ModelData);`
`14`	`14`	`}`
`15`	`15`
	`16`	`+[StructLayout(LayoutKind.Explicit, Size = 0x158)]`
	`17`	`+public unsafe struct MeddleModel`
	`18`	`+{`
	`19`	`+ [FieldOffset(0x0)] public FFXIVClientStructs.FFXIV.Client.Graphics.Render.Model* Base;`
	`20`	`+ [FieldOffset(0x28)] public uint Flags; // bit 0: body visible, bit 1: attributes dirty, bit 2: shapes dirty`
	`21`	`+`
	`22`	`+ public bool BodyVisible => (Flags & 1) != 0;`
	`23`	`+}`
	`24`	`+`
`16`	`25`
`17`	`26`	`public readonly struct ModelResourceHandleData`
`18`	`27`	`{`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ private void ResolveInstance(ParsedInstance instance)`
`189`	`189`	`materials.Add(materialInfo);`
`190`	`190`	`}`
`191`	`191`
`192`		`- var modelInfo = new ParsedModelInfo(path, path, null, null, materials.ToArray(), null, null);`
	`192`	`+ var modelInfo = new ParsedModelInfo(path, path, true, null, null, materials.ToArray(), null, null);`
`193`	`193`	`return modelInfo;`
`194`	`194`	`}`
`195`	`195`