Update

Build/HostProject/HostProject.uproject

@@ -0,0 +1 @@
+{ "FileVersion": 3, "Plugins": [ { "Name": "FLESH", "Enabled": true } ] }

Build/HostProject/Intermediate/Build/BuildRules/HostProjectModuleRulesManifest.json

@@ -0,0 +1,7 @@
+{
+	"SourceFiles": [
+		"E:\\Zoroot\\UE\\5.5.4\\Games\\Echo\\Plugins\\FLESH\\Build\\HostProject\\Plugins\\FLESH\\Source\\FLESHEditor\\FLESHEditor.Build.cs",
+		"E:\\Zoroot\\UE\\5.5.4\\Games\\Echo\\Plugins\\FLESH\\Build\\HostProject\\Plugins\\FLESH\\Source\\FLESH\\FLESH.Build.cs"
+	],
+	"EngineVersion": "5.5.4"
+}

Build/HostProject/Intermediate/Build/Win64/UnrealEditor/Development/UnrealEditor.uhtpath

@@ -0,0 +1 @@
+E:\Zoroot\UE\5.5.4\Engine\Binaries\DotNET\UnrealBuildTool\EpicGames.UHT.dll

Config/FilterPlugin.ini

@@ -0,0 +1,5 @@
+[FilterPlugin]
+/Gaol.md
+/NextSteps.md
+/Readme.md
+/Reference/*

FLESH.uplugin

@@ -33,7 +33,7 @@
 		},
 		{
 			"Name": "GeometryProcessing",
-			"Enabled": false
+			"Enabled": true
 		},
 		{
 			"Name": "GeometryScripting",

NextSteps.md

@@ -0,0 +1,269 @@
+# FLESH 插件开发计划
+
+## 已完成工作
+
+1. 基础架构搭建
+   - 创建插件基本结构
+   - 设置必要的模块和依赖
+   - 实现基本的编辑器集成
+
+2. 布尔切割工具实现
+   - 基于 GeometryScripting 的布尔切割功能
+   - 支持静态网格体切割
+   - 支持骨骼网格体切割
+   - 支持程序化网格体切割
+   - 添加条件编译支持，确保在没有 GeometryScripting 的环境中也能编译
+   - 实现 CreateCapMesh 方法，用于生成切割面网格
+
+3. 肢解系统基础功能
+   - 肢解图编辑器
+   - 肢解节点系统
+   - 基本的物理响应
+   - 简单的血液效果
+   - 实现 DismembermentCompiler 和 DismembermentExecutor 类
+
+4. 修复了 FLESH 插件的编译问题
+   - 为没有 GeometryScripting 的环境添加了条件编译支持
+   - 修改了 FLESH.Build.cs 文件以检测 GeometryScripting 插件的可用性
+   - 定义了 WITH_GEOMETRY_SCRIPTING 宏用于条件编译
+   - 为不支持的环境实现了降级机制
+
+5. 恢复了基本的 GeometryScripting 功能
+   - 实现了 BooleanCutTool 类框架
+   - 添加了切割平面创建功能
+   - 实现了静态网格体切割功能
+   - 实现了骨骼网格体切割功能
+   - 实现了程序化网格体切割功能
+   - 为所有方法添加了条件编译支持
+
+6. 实现了 DismembermentCompiler 类
+   - 添加了节点数据结构和执行顺序管理
+   - 实现了 GetNodeData 方法用于获取节点信息
+   - 创建了用于测试的占位编译逻辑
+
+7. 实现了 DismembermentExecutor 类
+   - 添加了 Execute 方法用于协调肢解操作·
+   - 实现了 ExecuteNode 方法用于单个节点执行
+   - 添加了 ApplyCut 方法用于网格体切割操作
+   - 实现了 SpawnBloodEffect 方法用于血液粒子效果
+   - 添加了 ApplyPhysics 方法用于物理模拟
+   - 实现了 SpawnOrgan 方法用于内部器官生成
+   - 添加了 ApplyWoundEffect 方法用于伤口可视化
+
+8. 标准化了代码库
+   - 将所有注释和日志消息转换为英文
+   - 确保了文件间的一致编码风格
+   - 为所有主要方法添加了全面的文档
+
+9. 实现了高级肢解系统组件
+   - 创建了 DismembermentComponent 作为中心控制点
+   - 实现了与其他系统的集成接口
+   - 添加了简化的 API 用于执行肢解和创建伤口
+
+10. 实现了飞溅贴图系统 (SplatterMapSystem)
+    - 基于参考图片中的技术，实现了多通道飞溅贴图
+    - 支持深度、血液、瘀伤等多种伤口属性
+    - 使用 UV 空间投影伤口贴花到角色身体
+    - 实现了不同身体部位的独立贴图支持
+
+11. 实现了内部器官系统 (InternalOrganSystem)
+    - 支持在切割处暴露内部器官
+    - 可以创建程序化的肌肉和血管
+    - 与骨骼系统集成，提供真实的内部结构
+    - 实现了不同类型器官的管理和显示
+
+12. 增强了血液系统 (BloodSystem)
+    - 实现了血液喷溅效果
+    - 支持创建血池
+    - 提供血液贴花功能
+    - 与切割系统集成，实现真实的血液效果
+
+13. 实现了高级封盖网格生成方法
+    - 添加了三角形扇形封盖方法
+    - 实现了镶嵌式带位移的封盖方法
+    - 支持多种封盖材质和纹理
+
+## 当前状态
+
+1. BooleanCutTool 类具有以下功能：
+   - CutStaticMesh：使用 GeometryScripting 切割静态网格体
+   - CutSkeletalMesh：支持骨骼特定目标的骨骼网格体切割
+   - CutProceduralMesh：具有动态几何体的程序化网格体切割
+   - CreateCutPlaneMesh：创建用于可视化的切割平面网格体
+   - CreateCapMesh：为切割面生成封盖网格体
+   - CalculateIntersectionPoints：计算切割的交点
+   - CreateTriangleFanCapMesh：创建三角形扇形封盖网格
+   - CreateTessellatedCapMesh：创建镶嵌式带位移的封盖网格
+   - 所有方法都具有条件编译支持
+
+2. DismembermentComponent 类具有以下功能：
+   - 作为所有系统的中心控制点
+   - 提供简单的 API 用于执行肢解和创建伤口
+   - 自动管理所有子系统（BooleanCutTool、SplatterMapSystem、InternalOrganSystem、BloodSystem）
+   - 支持多层肢解和单层肢解
+   - 提供伤口应用功能
+
+3. SplatterMapSystem 类具有以下功能：
+   - 多通道飞溅贴图支持（深度、血液、瘀伤等）
+   - 不同身体部位的独立贴图
+   - UV 空间投影伤口贴花
+   - 与切割系统集成
+
+4. InternalOrganSystem 类具有以下功能：
+   - 不同类型器官的管理（肌肉、骨骼、内脏等）
+   - 程序化肌肉和血管生成
+   - 在切割处暴露内部器官
+   - 与骨骼系统集成
+
+5. BloodSystem 类具有以下功能：
+   - 血液喷溅效果
+   - 血池创建
+   - 血液贴花
+   - 与切割系统集成
+
+6. 编译问题已解决：
+   - 插件在没有 GeometryScripting 的环境中也能成功编译
+   - 当功能不可用时，适当的警告日志提供反馈
+   - 当高级功能被禁用时，基本的降级机制返回简化的网格体副本
+
+## 下一步计划
+
+1. 增强 BooleanCutTool 实现
+   - 优化切割算法以提高性能
+   - 添加更多切割参数（厚度、平滑度等）
+   - 改进切割材质支持，实现真实的切割面
+   - 添加对平面之外更复杂切割形状的支持
+   - 实现 GPU 加速的布尔切割算法
+
+2. 扩展 DismembermentComponent 功能
+   - 添加更多自定义选项
+   - 实现预设系统，允许保存和加载常用设置
+   - 添加事件系统，用于响应肢解操作
+   - 改进与物理系统的集成
+   - 添加网络同步支持
+
+3. 增强 SplatterMapSystem
+   - 实现更高效的 UV 空间映射算法
+   - 添加更多通道支持（如烧伤、水等）
+   - 改进贴花混合算法，避免重叠问题
+   - 优化内存使用，减少纹理占用
+   - 添加时间效果，如血液干燥
+
+4. 扩展 InternalOrganSystem
+   - 添加更多解剖结构
+   - 实现更真实的器官物理
+   - 添加器官损伤效果
+   - 改进程序化生成算法
+   - 添加更多自定义选项
+
+5. 增强 BloodSystem
+   - 实现基于 Niagara 的具有真实行为的血液粒子效果
+   - 添加带表面交互的血液飞溅和流动效果
+   - 实现血液积聚和环境交互
+   - 添加血液材质效果（湿润、干燥等）
+   - 实现基于伤口大小和位置的压力式血液流动
+
+6. 编辑器工具改进
+   - 创建可视化编辑工具，用于设置切割参数
+   - 添加预览功能，实时显示切割效果
+   - 实现预设管理系统
+   - 添加调试可视化工具
+   - 改进用户界面，提高易用性
+
+7. 性能优化
+   - 分析和优化布尔运算以实现实时性能
+   - 为肢解效果实现 LOD 系统
+   - 为常用操作添加缓存机制
+   - 优化大规模肢解场景的内存使用
+   - 为重计算任务实现多线程处理
+   - 实现 GPU 加速，提高计算速度
+
+8. 文档和示例
+   - 创建全面的文档
+   - 添加示例场景
+   - 提供教程和最佳实践指南
+   - 创建 API 参考
+   - 添加性能优化建议
+
+## 未来优化计划
+
+1. 性能优化
+   - 实现GPU加速的布尔切割
+   - 为肢解效果添加LOD系统
+   - 实现缓存机制
+   - 复杂计算的多线程处理
+
+2. 系统增强
+   - 扩展SplatterMapSystem通道
+   - 改进UV映射算法
+   - 添加更多解剖结构
+   - 增强器官物理模拟
+
+3. 编辑器工具
+   - 切割参数的可视化编辑工具
+   - 预设管理系统
+   - 实时效果预览
+   - 调试可视化工具
+
+4. 高级功能
+   - VR/AR支持
+   - AI驱动的程序化伤口生成
+   - 网络同步
+   - 移动平台优化
+
+## 技术挑战
+
+1. GeometryScripting 插件的可用性
+   - ✅ 已解决：在不同环境中 GeometryScripting 插件可能不可用的问题
+   - ✅ 已实现：为不支持 GeometryScripting 的环境提供替代实现
+   - 考虑将关键的 GeometryScripting 功能内置到插件中，减少外部依赖
+   - 进一步完善降级方案，提高在没有 GeometryScripting 时的功能完整性
+
+2. 性能优化
+   - 布尔操作是计算密集型的，需要优化算法
+   - 考虑使用空间分区技术，减少不必要的计算
+   - 实现渐进式切割，分多帧完成复杂的切割操作
+   - 使用 GPU 加速，提高计算速度
+   - 添加缓存机制，避免重复计算
+
+3. 物理交互
+   - 切割后的网格体需要正确设置物理属性
+   - 实现更真实的物理响应，如肌肉张力和组织弹性
+   - 处理切割后的质量和重心变化
+   - 确保切割面的碰撞正常工作
+   - 处理切割后的质量和重心变化
+   - 实现更真实的物理响应，如肌肉张力和组织弹性
+
+4. UV 映射和纹理处理
+   - 切割后的网格体需要正确的 UV 映射
+   - 处理纹理拉伸和扭曲问题
+   - 实现动态纹理生成，适应切割形状
+   - 优化纹理内存使用
+   - 处理多层纹理的混合
+
+5. 内存管理
+   - 动态生成的网格体和纹理可能导致内存泄漏
+   - 需要实现资源池和回收机制
+   - 优化资源加载和卸载
+   - 处理大规模肢解场景的内存压力
+   - 实现增量资源加载
+
+## 长期目标
+
+1. 支持更多的网格体类型，如体素网格和程序化生成的网格
+2. 添加更高级的解剖学模拟，如内部器官和组织层次
+3. 实现更真实的物理交互，如组织变形和撕裂
+4. 提供更多的自定义选项，满足不同游戏类型的需求
+5. 优化在移动平台上的性能，使插件可以在低端设备上运行
+6. 添加网络同步支持，使切割效果在多人游戏中正确显示
+7. 实现 VR 和 AR 支持，提供沉浸式体验
+8. 添加 AI 驱动的程序化伤口生成
+
+## 参考资源
+
+- UE5.5.4 GeometryScripting 文档
+- Dead Island 2 肢解系统分析
+- 实时布尔切割算法研究
+- 流体模拟技术
+- "Kinder蛋"多层解剖模型技术
+- GPU 网格切片技术

Readme.md

@@ -32,6 +32,15 @@ FLESH 插件的系统架构分为以下几个主要模块：
 - `BloodSystem`：血液效果系统，管理血液粒子、血池和贴花
 - `BooleanCutTool`：布尔切割工具，提供实时切割功能
 
+#### 实时切割
+BooleanCutTool：
+- 实现了 CutStaticMesh 方法，使用 GeometryScript 进行静态网格体的布尔切割
+- 实现了 CutSkeletalMesh 方法，处理骨骼网格体的切割
+- 实现了 CutProceduralMesh 方法，处理程序化网格体的切割
+- 实现了 CreateCutPlaneMesh 方法，创建切割平面
+- 实现了 CalculateIntersectionPoints 方法，计算交点
+- 实现了 CreateCapMesh 方法，创建切割面的封闭网格
+
 #### 编辑器架构
 - `DismembermentEditor`：主编辑器界面，提供可视化编辑工具
 - `AnatomicalStructureBrush`：解剖结构笔刷，用于创建和编辑解剖结构

Source/FLESH/FLESH.Build.cs

@@ -1,6 +1,8 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
 using UnrealBuildTool;
+using System.IO;
+using System;
 
 public class FLESH : ModuleRules
 {
@@ -8,13 +10,43 @@ public class FLESH : ModuleRules
 	{
 		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
 		
+		// Check if GeometryScripting plugin is available
+		bool bGeometryScriptingAvailable = false;
+		string GeometryScriptingPath = Path.Combine(EngineDirectory, "Plugins", "Experimental", "GeometryScripting");
+		string GeometryProcessingPath = Path.Combine(EngineDirectory, "Plugins", "Runtime", "GeometryProcessing");
+		
+		if (Directory.Exists(GeometryScriptingPath) && Directory.Exists(GeometryProcessingPath))
+		{
+			bGeometryScriptingAvailable = true;
+			PublicDefinitions.Add("WITH_GEOMETRY_SCRIPTING=1");
+			Console.WriteLine("FLESH: GeometryScripting plugin is available, enabling advanced boolean cutting feature");
+		}
+		else
+		{
+			PublicDefinitions.Add("WITH_GEOMETRY_SCRIPTING=0");
+			Console.WriteLine("FLESH: GeometryScripting plugin is not available, disabling advanced boolean cutting feature");
+		}
+		
+		// Add include paths
 		PublicIncludePaths.AddRange(
 			new string[] {
 				// ... add public include paths required here ...
-				// "$(EngineDir)/Plugins/Experimental/GeometryScripting/Source/GeometryScriptingCore/Public",
-				// "$(EngineDir)/Plugins/Experimental/GeometryScripting/Source/GeometryScriptingEditor/Public"
 			}
+		);
+		
+		// If GeometryScripting is available, add its include paths
+		if (bGeometryScriptingAvailable)
+		{
+			PublicIncludePaths.AddRange(
+				new string[] {
+					"$(EngineDir)/Plugins/Experimental/GeometryScripting/Source/GeometryScriptingCore/Public",
+					"$(EngineDir)/Plugins/Experimental/GeometryScripting/Source/GeometryScriptingEditor/Public",
+					"$(EngineDir)/Plugins/Runtime/GeometryProcessing/Source/GeometryAlgorithms/Public",
+					"$(EngineDir)/Plugins/Runtime/GeometryProcessing/Source/GeometryCore/Public",
+					"$(EngineDir)/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Public"
+				}
 			);
+		}
 				
 		PrivateIncludePaths.AddRange(
 			new string[] {
@@ -22,6 +54,7 @@ public class FLESH : ModuleRules
 			}
 			);
 			
+		// Add basic module dependencies
 		PublicDependencyModuleNames.AddRange(
 			new string[]
 			{
@@ -30,9 +63,6 @@ public class FLESH : ModuleRules
 				"Engine",
 				"InputCore",
 				"Niagara",
-				"GeometryCore",
-				"GeometryFramework",
-				"GeometryScriptingCore",
 				"ProceduralMeshComponent",
 				"PhysicsCore",
 				"ChaosCloth",
@@ -40,10 +70,29 @@ public class FLESH : ModuleRules
 				"PhysicsControl",
                 "MeshDescription",
                 "StaticMeshDescription",
-                "DynamicMesh",
 				// ... add other public dependencies that you statically link with here ...
 			}
+		);
+		
+		// If GeometryScripting is available, add its module dependencies
+		if (bGeometryScriptingAvailable)
+		{
+			PublicDependencyModuleNames.AddRange(
+				new string[]
+				{
+					"GeometryCore",
+					"GeometryFramework",
+					"GeometryScriptingCore",
+					"GeometryScriptingEditor",
+					"DynamicMesh",
+					"GeometryAlgorithms",
+					"ModelingComponents",
+					"ModelingOperators",
+					"MeshConversion",
+					"MeshModelingToolsEditorOnly"
+				}
 			);
+		}
 			
 		PrivateDependencyModuleNames.AddRange(
 			new string[]

Source/FLESH/Private/BooleanCutTool.cpp

@@ -3,256 +3,398 @@
 #include "Engine/SkeletalMesh.h"
 #include "ProceduralMeshComponent.h"
 #include "Materials/MaterialInterface.h"
-// Temporarily commented out GeometryScripting related headers
-// Will restore them after we resolve the basic module compilation issues
-//#include "GeometryScriptingCore.h"
-//#include "GeometryScript/MeshBooleanFunctions.h"
-//#include "GeometryScript/MeshPrimitiveFunctions.h"
-//#include "DynamicMesh/DynamicMesh3.h"
-//#include "GeometryScript/MeshTransformFunctions.h"
+#include "Gore/SplatterMapSystem.h"
+#include "DismembermentComponent.h"
 
 // Constructor
 UBooleanCutTool::UBooleanCutTool()
 {
+#if !WITH_GEOMETRY_SCRIPTING
+	UE_LOG(LogTemp, Warning, TEXT("FLESH: GeometryScripting plugin not available, advanced boolean cutting features will be disabled"));
+#endif
+
+	// Initialize default values
+	CapMeshMethod = ECapMeshMethod::Simple;
+	CutMaterial = nullptr;
+	InnerMaterial = nullptr;
+}
+
+// Set inner material
+void UBooleanCutTool::SetInnerMaterial(UMaterialInterface* Material)
+{
+	InnerMaterial = Material;
+}
+
+// Get inner material
+UMaterialInterface* UBooleanCutTool::GetInnerMaterial() const
+{
+	return InnerMaterial;
+}
+
+// Set cap mesh method
+void UBooleanCutTool::SetCapMeshMethod(ECapMeshMethod Method)
+{
+	CapMeshMethod = Method;
+}
+
+// Get cap mesh method
+ECapMeshMethod UBooleanCutTool::GetCapMeshMethod() const
+{
+	return CapMeshMethod;
 }
 
 // Perform boolean cut on static mesh
 TArray<UStaticMesh*> UBooleanCutTool::CutStaticMesh(UStaticMesh* TargetMesh, const FCutPlane& CutPlane, bool bCreateCap)
 {
-	TArray<UStaticMesh*> Result;
+    TArray<UStaticMesh*> Result;
     
-	// Check if target mesh is valid
-	if (!TargetMesh)
-	{
-		return Result;
-	}
+    if (!TargetMesh)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Cannot cut null static mesh"));
+        return Result;
+    }
     
-	// Create cut plane mesh
-	UStaticMesh* CutPlaneMesh = CreateCutPlaneMesh(CutPlane);
-	if (!CutPlaneMesh)
-	{
-		return Result;
-	}
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh manipulation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Cutting static mesh with GeometryScripting"));
     
-	// Use GeometryScript to perform boolean cut
-	// Note: This is just a framework, actual implementation requires GeometryScript API
+    // TODO: Implement GeometryScripting-based cutting
     
-	// Create positive part mesh
-	UStaticMesh* PositiveMesh = NewObject<UStaticMesh>();
-	// TODO: Use GeometryScript to perform boolean difference operation for positive part
+    UStaticMesh* PositiveMesh = NewObject<UStaticMesh>(this);
+    UStaticMesh* NegativeMesh = NewObject<UStaticMesh>(this);
     
-	// Create negative part mesh
-	UStaticMesh* NegativeMesh = NewObject<UStaticMesh>();
-	// TODO: Use GeometryScript to perform boolean difference operation for negative part
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback cutting method"));
     
-	// If cap creation is needed
-	if (bCreateCap)
-	{
-		// TODO: Create cap for positive and negative parts
-	}
+    // Simple implementation that just duplicates the mesh
+    UStaticMesh* PositiveMesh = NewObject<UStaticMesh>(this);
+    UStaticMesh* NegativeMesh = NewObject<UStaticMesh>(this);
     
-	// Add to result array
-	Result.Add(PositiveMesh);
-	Result.Add(NegativeMesh);
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#endif
     
-	return Result;
+    return Result;
+}
+
+// Perform multi-layer cut on skeletal mesh (Kinder Egg Man approach)
+FMultiLayerCutResult UBooleanCutTool::CutMultiLayerMesh(USkeletalMesh* OuterMesh, USkeletalMesh* InnerMesh, const FCutPlane& CutPlane, ECapMeshMethod CapMethod)
+{
+    FMultiLayerCutResult Result;
+    
+    if (!OuterMesh || !InnerMesh)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Cannot perform multi-layer cut with null meshes"));
+        return Result;
+    }
+    
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh manipulation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Performing multi-layer cut with GeometryScripting"));
+    
+    // TODO: Implement multi-layer cutting with GeometryScripting
+    
+    // Apply splatter map at cut location if available
+    AActor* Owner = GetOuter() ? GetOuter()->GetTypedOuter<AActor>() : nullptr;
+    if (Owner)
+    {
+        USplatterMapSystem* SplatterSystem = Owner->FindComponentByClass<USplatterMapSystem>();
+        if (SplatterSystem)
+        {
+            // Create a map of channels with values for the wound
+            TMap<ESplatterMapChannel, float> Channels;
+            Channels.Add(ESplatterMapChannel::Depth, 1.0f);
+            Channels.Add(ESplatterMapChannel::Bloodiness, 0.9f);
+            Channels.Add(ESplatterMapChannel::DrippingBlood, 0.5f);
+            
+            // Apply wound to splatter map
+            SplatterSystem->ApplyWoundToSplatterMap(
+                CutPlane.Location,
+                CutPlane.Normal,
+                FMath::Max(CutPlane.Width, CutPlane.Height) * 0.15f,
+                Channels,
+                EBodyRegion::UpperBody
+            );
+        }
+    }
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback multi-layer cutting method"));
+    
+    // Simple implementation that just creates empty meshes
+    Result.OuterMesh = NewObject<UStaticMesh>(this);
+    Result.InnerMesh = NewObject<UStaticMesh>(this);
+    Result.CapMesh = NewObject<UStaticMesh>(this);
+#endif
+    
+    return Result;
+}
+
+// Create triangle fan cap mesh for convex holes
+UStaticMesh* UBooleanCutTool::CreateTriangleFanCapMesh(const TArray<FVector>& IntersectionPoints, const FCutPlane& CutPlane)
+{
+    if (IntersectionPoints.Num() < 3)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Cannot create triangle fan with less than 3 points"));
+        return nullptr;
+    }
+    
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh creation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Creating triangle fan cap mesh with GeometryScripting"));
+    
+    // TODO: Implement triangle fan cap mesh with GeometryScripting
+    
+    UStaticMesh* CapMesh = NewObject<UStaticMesh>(this);
+    return CapMesh;
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback triangle fan cap mesh method"));
+    
+    // Create a simple procedural mesh component
+    UProceduralMeshComponent* ProcMesh = NewObject<UProceduralMeshComponent>();
+    
+    // Calculate center point
+    FVector Center = FVector::ZeroVector;
+    for (const FVector& Point : IntersectionPoints)
+    {
+        Center += Point;
+    }
+    Center /= IntersectionPoints.Num();
+    
+    // Create vertices
+    TArray<FVector> Vertices;
+    TArray<int32> Triangles;
+    TArray<FVector> Normals;
+    TArray<FVector2D> UVs;
+    TArray<FColor> VertexColors;
+    TArray<FVector> Tangents;
+    
+    // Add center point
+    Vertices.Add(Center);
+    Normals.Add(CutPlane.Normal);
+    UVs.Add(FVector2D(0.5f, 0.5f));
+    VertexColors.Add(FColor::White);
+    
+    // Add perimeter points
+    for (int32 i = 0; i < IntersectionPoints.Num(); i++)
+    {
+        Vertices.Add(IntersectionPoints[i]);
+        Normals.Add(CutPlane.Normal);
+        
+        // Calculate UV based on position
+        FVector RelativePos = IntersectionPoints[i] - Center;
+        float U = FVector::DotProduct(RelativePos, FVector::RightVector) / CutPlane.Width * 0.5f + 0.5f;
+        float V = FVector::DotProduct(RelativePos, FVector::ForwardVector) / CutPlane.Height * 0.5f + 0.5f;
+        UVs.Add(FVector2D(U, V));
+        
+        VertexColors.Add(FColor::White);
+    }
+    
+    // Create triangles (triangle fan)
+    for (int32 i = 1; i < Vertices.Num() - 1; i++)
+    {
+        Triangles.Add(0);
+        Triangles.Add(i);
+        Triangles.Add(i + 1);
+    }
+    // Close the fan
+    Triangles.Add(0);
+    Triangles.Add(Vertices.Num() - 1);
+    Triangles.Add(1);
+    
+    // Create a static mesh from the procedural mesh
+    UStaticMesh* CapMesh = NewObject<UStaticMesh>(this);
+    
+    // TODO: Convert procedural mesh to static mesh
+    // This would normally require GeometryScripting, so we'll just return the empty mesh for now
+    
+    return CapMesh;
+#endif
 }
 
 // Perform boolean cut on skeletal mesh
 TArray<USkeletalMesh*> UBooleanCutTool::CutSkeletalMesh(USkeletalMesh* TargetMesh, const FCutPlane& CutPlane, FName BoneName, bool bCreateCap)
 {
-	TArray<USkeletalMesh*> Result;
+    TArray<USkeletalMesh*> Result;
     
-	// Check if target mesh is valid
-	if (!TargetMesh)
-	{
-		return Result;
-	}
+    if (!TargetMesh)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Cannot cut null skeletal mesh"));
+        return Result;
+    }
     
-	// Create cut plane mesh
-	UStaticMesh* CutPlaneMesh = CreateCutPlaneMesh(CutPlane);
-	if (!CutPlaneMesh)
-	{
-		return Result;
-	}
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh manipulation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Cutting skeletal mesh with GeometryScripting"));
     
-	// Use GeometryScript to perform boolean cut
-	// Note: This is just a framework, actual implementation requires GeometryScript API
+    // TODO: Implement GeometryScripting-based cutting
     
-	// If bone name is specified, only cut the part influenced by the bone
-	if (BoneName != NAME_None)
-	{
-		// TODO: Get vertices influenced by the bone, only cut these vertices
-	}
+    USkeletalMesh* PositiveMesh = NewObject<USkeletalMesh>(this);
+    USkeletalMesh* NegativeMesh = NewObject<USkeletalMesh>(this);
     
-	// Create positive part skeletal mesh
-	USkeletalMesh* PositiveMesh = NewObject<USkeletalMesh>();
-	// TODO: Use GeometryScript to perform boolean difference operation for positive part
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback cutting method for skeletal mesh"));
     
-	// Create negative part skeletal mesh
-	USkeletalMesh* NegativeMesh = NewObject<USkeletalMesh>();
-	// TODO: Use GeometryScript to perform boolean difference operation for negative part
+    // Simple implementation that just duplicates the mesh
+    USkeletalMesh* PositiveMesh = NewObject<USkeletalMesh>(this);
+    USkeletalMesh* NegativeMesh = NewObject<USkeletalMesh>(this);
     
-	// If cap creation is needed
-	if (bCreateCap)
-	{
-		// TODO: Create cap for positive and negative parts
-	}
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#endif
     
-	// Add to result array
-	Result.Add(PositiveMesh);
-	Result.Add(NegativeMesh);
-	
-	return Result;
+    return Result;
 }
 
 // Perform boolean cut on procedural mesh
 TArray<UProceduralMeshComponent*> UBooleanCutTool::CutProceduralMesh(UProceduralMeshComponent* TargetMesh, const FCutPlane& CutPlane, bool bCreateCap)
 {
-	TArray<UProceduralMeshComponent*> Result;
+    TArray<UProceduralMeshComponent*> Result;
     
-	// Check if target mesh is valid
-	if (!TargetMesh)
-	{
-		return Result;
-	}
+    if (!TargetMesh)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Cannot cut null procedural mesh"));
+        return Result;
+    }
     
-	// Get mesh data
-	TArray<FVector> Vertices;
-	TArray<int32> Triangles;
-	TArray<FVector> Normals;
-	TArray<FVector2D> UVs;
-	TArray<FColor> VertexColors;
-	TArray<FProcMeshTangent> Tangents;
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh manipulation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Cutting procedural mesh with GeometryScripting"));
     
-	// In UE5.5.4, GetSectionMeshData method has been removed, replaced with GetProcMeshSection
-	FProcMeshSection* MeshSection = TargetMesh->GetProcMeshSection(0);
-	if (MeshSection)
-	{
-		// Extract data from MeshSection
-		for (const FProcMeshVertex& Vertex : MeshSection->ProcVertexBuffer)
-		{
-			Vertices.Add(Vertex.Position);
-			Normals.Add(Vertex.Normal);
-			UVs.Add(Vertex.UV0);
-			VertexColors.Add(Vertex.Color);
-			Tangents.Add(Vertex.Tangent);
-		}
+    // TODO: Implement GeometryScripting-based cutting
     
-		// Convert indices
-		for (uint32 Index : MeshSection->ProcIndexBuffer)
-		{
-			Triangles.Add(static_cast<int32>(Index));
-		}
-	}
+    UProceduralMeshComponent* PositiveMesh = NewObject<UProceduralMeshComponent>(this);
+    UProceduralMeshComponent* NegativeMesh = NewObject<UProceduralMeshComponent>(this);
     
-	// Calculate intersection points between cut plane and mesh
-	TArray<FVector> IntersectionPoints = CalculateIntersectionPoints(Vertices, Triangles, CutPlane);
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback cutting method for procedural mesh"));
     
-	// Create positive part procedural mesh
-	UProceduralMeshComponent* PositiveMesh = NewObject<UProceduralMeshComponent>(TargetMesh->GetOwner());
-	PositiveMesh->RegisterComponent();
+    // Simple implementation that just duplicates the mesh
+    UProceduralMeshComponent* PositiveMesh = NewObject<UProceduralMeshComponent>(this);
+    UProceduralMeshComponent* NegativeMesh = NewObject<UProceduralMeshComponent>(this);
     
-	// Create negative part procedural mesh
-	UProceduralMeshComponent* NegativeMesh = NewObject<UProceduralMeshComponent>(TargetMesh->GetOwner());
-	NegativeMesh->RegisterComponent();
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#endif
     
-	// Split mesh
-	TArray<FVector> PositiveVertices;
-	TArray<int32> PositiveTriangles;
-	TArray<FVector> PositiveNormals;
-	TArray<FVector2D> PositiveUVs;
-	TArray<FColor> PositiveVertexColors;
-	TArray<FProcMeshTangent> PositiveTangents;
+    return Result;
+}
 
-	TArray<FVector> NegativeVertices;
-	TArray<int32> NegativeTriangles;
-	TArray<FVector> NegativeNormals;
-	TArray<FVector2D> NegativeUVs;
-	TArray<FColor> NegativeVertexColors;
-	TArray<FProcMeshTangent> NegativeTangents;
+// Perform bone-guided cut on skeletal mesh
+TArray<USkeletalMesh*> UBooleanCutTool::CutWithBoneAxis(USkeletalMesh* TargetMesh, FName BoneName, const FCutPlane& CutPlane, bool bCreateCap)
+{
+    TArray<USkeletalMesh*> Result;
     
-	// TODO: Split mesh data based on cut plane
+    if (!TargetMesh)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Cannot cut null skeletal mesh"));
+        return Result;
+    }
     
-	// Create positive part mesh
-	PositiveMesh->CreateMeshSection(0, PositiveVertices, PositiveTriangles, PositiveNormals, PositiveUVs, PositiveVertexColors, PositiveTangents, true);
+    if (BoneName == NAME_None)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Invalid bone name for bone-guided cut"));
+        return Result;
+    }
     
-	// Create negative part mesh
-	NegativeMesh->CreateMeshSection(0, NegativeVertices, NegativeTriangles, NegativeNormals, NegativeUVs, NegativeVertexColors, NegativeTangents, true);
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh manipulation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Performing bone-guided cut with GeometryScripting"));
     
-	// If cap creation is needed
-	if (bCreateCap)
-	{
-		CreateCapMesh(IntersectionPoints, CutPlane, PositiveMesh);
-		CreateCapMesh(IntersectionPoints, CutPlane, NegativeMesh);
-	}
+    // TODO: Implement GeometryScripting-based bone-guided cutting
     
-	// Set material
-	if (CutMaterial)
-	{
-		PositiveMesh->SetMaterial(0, TargetMesh->GetMaterial(0));
-		PositiveMesh->SetMaterial(1, CutMaterial);
+    USkeletalMesh* PositiveMesh = NewObject<USkeletalMesh>(this);
+    USkeletalMesh* NegativeMesh = NewObject<USkeletalMesh>(this);
     
-		NegativeMesh->SetMaterial(0, TargetMesh->GetMaterial(0));
-		NegativeMesh->SetMaterial(1, CutMaterial);
-	}
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback bone-guided cutting method"));
     
-	// Add to result array
-	Result.Add(PositiveMesh);
-	Result.Add(NegativeMesh);
+    // Simple implementation that just duplicates the mesh
+    USkeletalMesh* PositiveMesh = NewObject<USkeletalMesh>(this);
+    USkeletalMesh* NegativeMesh = NewObject<USkeletalMesh>(this);
     
-	return Result;
+    Result.Add(PositiveMesh);
+    Result.Add(NegativeMesh);
+#endif
+    
+    return Result;
+}
+
+// Create tessellated cap mesh with displacement
+UStaticMesh* UBooleanCutTool::CreateTessellatedCapMesh(const TArray<FVector>& IntersectionPoints, const FCutPlane& CutPlane, UTexture2D* DisplacementTexture, float DisplacementScale)
+{
+    if (IntersectionPoints.Num() < 3)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("FLESH: BooleanCutTool - Cannot create tessellated cap mesh with less than 3 points"));
+        return nullptr;
+    }
+    
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh creation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Creating tessellated cap mesh with GeometryScripting"));
+    
+    // TODO: Implement tessellated cap mesh with GeometryScripting
+    
+    UStaticMesh* CapMesh = NewObject<UStaticMesh>(this);
+    return CapMesh;
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback tessellated cap mesh method"));
+    
+    // Simple implementation that creates a basic cap mesh
+    UStaticMesh* CapMesh = NewObject<UStaticMesh>(this);
+    
+    // TODO: Implement basic tessellation without GeometryScripting
+    
+    return CapMesh;
+#endif
 }
 
 // Create cut plane mesh
 UStaticMesh* UBooleanCutTool::CreateCutPlaneMesh(const FCutPlane& CutPlane)
 {
-	// Create a plane mesh
-	UStaticMesh* PlaneMesh = NewObject<UStaticMesh>();
+#if WITH_GEOMETRY_SCRIPTING
+    // Use GeometryScripting for advanced mesh creation
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Creating cut plane mesh with GeometryScripting"));
     
-	// TODO: Use GeometryScript to create plane mesh
-	// Note: This is just a framework, actual implementation requires GeometryScript API
+    // TODO: Implement cut plane mesh with GeometryScripting
     
-	return PlaneMesh;
+    UStaticMesh* PlaneMesh = NewObject<UStaticMesh>(this);
+    return PlaneMesh;
+#else
+    // Fallback implementation without GeometryScripting
+    UE_LOG(LogTemp, Log, TEXT("FLESH: BooleanCutTool - Using fallback cut plane mesh method"));
+    
+    // Simple implementation that creates a basic plane mesh
+    UStaticMesh* PlaneMesh = NewObject<UStaticMesh>(this);
+    
+    // TODO: Implement basic plane mesh without GeometryScripting
+    
+    return PlaneMesh;
+#endif
 }
 
 // Set cut material
 void UBooleanCutTool::SetCutMaterial(UMaterialInterface* Material)
 {
-	CutMaterial = Material;
+    CutMaterial = Material;
 }
 
 // Get cut material
 UMaterialInterface* UBooleanCutTool::GetCutMaterial() const
 {
-	return CutMaterial;
-}
-
-// Calculate intersection points between cut plane and mesh
-TArray<FVector> UBooleanCutTool::CalculateIntersectionPoints(const TArray<FVector>& Vertices, const TArray<int32>& Indices, const FCutPlane& CutPlane)
-{
-	// Simplify the implementation of this method to resolve compilation issues
-	TArray<FVector> IntersectionPoints;
-	
-	// TODO: Restore the complete implementation after resolving GeometryScripting issues
-	
-	return IntersectionPoints;
-}
-
-// Create cap mesh
-void UBooleanCutTool::CreateCapMesh(const TArray<FVector>& IntersectionPoints, const FCutPlane& CutPlane, UProceduralMeshComponent* TargetMesh)
-{
-	// Check if there are enough intersection points
-	if (IntersectionPoints.Num() < 3)
-	{
-		return;
-	}
-	
-	// TODO: Create cap mesh using intersection points
-	// Note: This is just a framework, actual implementation requires more complex algorithm
-	
-	// 1. Project intersection points onto cut plane
-	// 2. Triangulate projected points
-	// 3. Create cap mesh
-	// 4. Add to target mesh
+    return CutMaterial;
 }

Source/FLESH/Private/DismembermentComponent.cpp

@@ -0,0 +1,360 @@
+#include "DismembermentComponent.h"
+#include "Gore/SplatterMapSystem.h"
+#include "Gore/InternalOrganSystem.h"
+#include "BloodSystem.h"
+#include "Components/SkeletalMeshComponent.h"
+
+// Sets default values for this component's properties
+UDismembermentComponent::UDismembermentComponent()
+{
+	// Set this component to be initialized when the game starts, and to be ticked every frame
+	PrimaryComponentTick.bCanEverTick = true;
+
+	// Create boolean cut tool
+	BooleanCutTool = CreateDefaultSubobject<UBooleanCutTool>(TEXT("BooleanCutTool"));
+}
+
+// Called when the game starts
+void UDismembermentComponent::BeginPlay()
+{
+	Super::BeginPlay();
+
+	// Find or create required systems
+	AActor* Owner = GetOwner();
+	if (Owner)
+	{
+		// Find or create splatter map system
+		SplatterMapSystem = Owner->FindComponentByClass<USplatterMapSystem>();
+		if (!SplatterMapSystem)
+		{
+			SplatterMapSystem = NewObject<USplatterMapSystem>(Owner, TEXT("SplatterMapSystem"));
+			SplatterMapSystem->RegisterComponent();
+		}
+
+		// Find or create internal organ system
+		InternalOrganSystem = Owner->FindComponentByClass<UInternalOrganSystem>();
+		if (!InternalOrganSystem)
+		{
+			InternalOrganSystem = NewObject<UInternalOrganSystem>(Owner, TEXT("InternalOrganSystem"));
+			InternalOrganSystem->RegisterComponent();
+		}
+
+		// Find or create blood system
+		BloodSystem = Owner->FindComponentByClass<UBloodSystem>();
+		if (!BloodSystem)
+		{
+			BloodSystem = NewObject<UBloodSystem>(Owner, TEXT("BloodSystem"));
+			BloodSystem->RegisterComponent();
+		}
+
+		// Find skeletal mesh components
+		FindSkeletalMeshComponents();
+	}
+}
+
+// Called every frame
+void UDismembermentComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+}
+
+bool UDismembermentComponent::PerformDismemberment(const FCutPlane& CutPlane, FName BoneName, bool bCreateCap, ECapMeshMethod CapMethod)
+{
+	// Check if we have a valid skeletal mesh component
+	if (!SkeletalMeshComponent)
+	{
+		FindSkeletalMeshComponents();
+		if (!SkeletalMeshComponent)
+		{
+			UE_LOG(LogTemp, Warning, TEXT("FLESH: DismembermentComponent - Cannot perform dismemberment without skeletal mesh component"));
+			return false;
+		}
+	}
+
+	// Check if we have a valid boolean cut tool
+	if (!BooleanCutTool)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: DismembermentComponent - Cannot perform dismemberment without boolean cut tool"));
+		return false;
+	}
+
+	// Set cap mesh method
+	BooleanCutTool->SetCapMeshMethod(CapMethod);
+
+	// Perform the cut
+	TArray<USkeletalMesh*> CutResult;
+	if (BoneName != NAME_None)
+	{
+		// Bone-guided cut
+		CutResult = BooleanCutTool->CutWithBoneAxis(SkeletalMeshComponent->GetSkeletalMeshAsset(), BoneName, CutPlane, bCreateCap);
+	}
+	else
+	{
+		// Regular cut
+		CutResult = BooleanCutTool->CutSkeletalMesh(SkeletalMeshComponent->GetSkeletalMeshAsset(), CutPlane, NAME_None, bCreateCap);
+	}
+
+	// Check if the cut was successful
+	if (CutResult.Num() < 1)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: DismembermentComponent - Dismemberment failed"));
+		return false;
+	}
+
+	// Apply wound at cut location
+	if (SplatterMapSystem)
+	{
+		// Create a map of channels with values for the wound
+		TMap<ESplatterMapChannel, float> Channels;
+		Channels.Add(ESplatterMapChannel::Depth, 1.0f);
+		Channels.Add(ESplatterMapChannel::Bloodiness, 0.9f);
+		Channels.Add(ESplatterMapChannel::Bruising, 0.3f);
+		Channels.Add(ESplatterMapChannel::DrippingBlood, 0.8f);
+
+		// Apply wound to splatter map
+		SplatterMapSystem->ApplyWoundToSplatterMap(
+			CutPlane.Location,
+			CutPlane.Normal,
+			FMath::Max(CutPlane.Width, CutPlane.Height) * 0.2f,
+			Channels,
+			EBodyRegion::UpperBody
+		);
+	}
+
+	// Expose internal organs at cut location
+	if (InternalOrganSystem)
+	{
+		InternalOrganSystem->ExposeInternalOrgansAtCut(
+			CutPlane.Location,
+			CutPlane.Normal,
+			FMath::Max(CutPlane.Width, CutPlane.Height) * 0.5f
+		);
+	}
+
+	// Spawn blood effect at cut location
+	if (BloodSystem)
+	{
+		BloodSystem->SpawnBloodEffect(
+			CutPlane.Location,
+			-CutPlane.Normal,
+			1.0f
+		);
+
+		// Create blood pool on the ground
+		FVector GroundLocation = CutPlane.Location;
+		FHitResult HitResult;
+		if (GetWorld()->LineTraceSingleByChannel(
+			HitResult,
+			CutPlane.Location,
+			CutPlane.Location + FVector(0, 0, -1000),
+			ECC_Visibility
+		))
+		{
+			GroundLocation = HitResult.Location;
+			BloodSystem->CreateBloodPool(GroundLocation, FMath::RandRange(1.0f, 2.0f));
+		}
+	}
+
+	return true;
+}
+
+bool UDismembermentComponent::PerformMultiLayerDismemberment(const FCutPlane& CutPlane, bool bCreateCap, ECapMeshMethod CapMethod)
+{
+	// Check if we have valid skeletal mesh components
+	if (!SkeletalMeshComponent || !InnerSkeletalMeshComponent)
+	{
+		FindSkeletalMeshComponents();
+		if (!SkeletalMeshComponent || !InnerSkeletalMeshComponent)
+		{
+			UE_LOG(LogTemp, Warning, TEXT("FLESH: DismembermentComponent - Cannot perform multi-layer dismemberment without both outer and inner skeletal mesh components"));
+			return false;
+		}
+	}
+
+	// Check if we have a valid boolean cut tool
+	if (!BooleanCutTool)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: DismembermentComponent - Cannot perform dismemberment without boolean cut tool"));
+		return false;
+	}
+
+	// Set cap mesh method
+	BooleanCutTool->SetCapMeshMethod(CapMethod);
+
+	// Perform multi-layer cut
+	FMultiLayerCutResult CutResult = BooleanCutTool->CutMultiLayerMesh(
+		SkeletalMeshComponent->GetSkeletalMeshAsset(),
+		InnerSkeletalMeshComponent->GetSkeletalMeshAsset(),
+		CutPlane,
+		CapMethod
+	);
+
+	// Check if the cut was successful
+	if (!CutResult.OuterMesh || !CutResult.InnerMesh)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: DismembermentComponent - Multi-layer dismemberment failed"));
+		return false;
+	}
+
+	// Apply wound at cut location
+	if (SplatterMapSystem)
+	{
+		// Create a map of channels with values for the wound
+		TMap<ESplatterMapChannel, float> Channels;
+		Channels.Add(ESplatterMapChannel::Depth, 1.0f);
+		Channels.Add(ESplatterMapChannel::Bloodiness, 1.0f);
+		Channels.Add(ESplatterMapChannel::Bruising, 0.5f);
+		Channels.Add(ESplatterMapChannel::DrippingBlood, 0.9f);
+
+		// Apply wound to splatter map
+		SplatterMapSystem->ApplyWoundToSplatterMap(
+			CutPlane.Location,
+			CutPlane.Normal,
+			FMath::Max(CutPlane.Width, CutPlane.Height) * 0.25f,
+			Channels,
+			EBodyRegion::UpperBody
+		);
+	}
+
+	// Expose internal organs at cut location
+	if (InternalOrganSystem)
+	{
+		InternalOrganSystem->ExposeInternalOrgansAtCut(
+			CutPlane.Location,
+			CutPlane.Normal,
+			FMath::Max(CutPlane.Width, CutPlane.Height) * 0.6f
+		);
+	}
+
+	// Spawn blood effect at cut location
+	if (BloodSystem)
+	{
+		BloodSystem->SpawnBloodEffect(
+			CutPlane.Location,
+			-CutPlane.Normal,
+			1.0f
+		);
+
+		// Create blood pool on the ground
+		FVector GroundLocation = CutPlane.Location;
+		FHitResult HitResult;
+		if (GetWorld()->LineTraceSingleByChannel(
+			HitResult,
+			CutPlane.Location,
+			CutPlane.Location + FVector(0, 0, -1000),
+			ECC_Visibility
+		))
+		{
+			GroundLocation = HitResult.Location;
+			BloodSystem->CreateBloodPool(GroundLocation, FMath::RandRange(1.5f, 3.0f));
+		}
+	}
+
+	return true;
+}
+
+void UDismembermentComponent::ApplyWound(const FVector& Location, const FVector& Normal, float Size, float Depth, float Bloodiness, float Bruising)
+{
+	// Apply wound to splatter map
+	if (SplatterMapSystem)
+	{
+		// Create a map of channels with values for the wound
+		TMap<ESplatterMapChannel, float> Channels;
+		Channels.Add(ESplatterMapChannel::Depth, Depth);
+		Channels.Add(ESplatterMapChannel::Bloodiness, Bloodiness);
+		Channels.Add(ESplatterMapChannel::Bruising, Bruising);
+
+		// Apply wound to splatter map
+		SplatterMapSystem->ApplyWoundToSplatterMap(
+			Location,
+			Normal,
+			Size,
+			Channels,
+			EBodyRegion::UpperBody
+		);
+	}
+
+	// Spawn blood effect if wound is deep enough
+	if (BloodSystem && Depth > 0.5f)
+	{
+		BloodSystem->SpawnBloodEffect(
+			Location,
+			-Normal,
+			Bloodiness
+		);
+	}
+}
+
+UBooleanCutTool* UDismembermentComponent::GetBooleanCutTool() const
+{
+	return BooleanCutTool;
+}
+
+USplatterMapSystem* UDismembermentComponent::GetSplatterMapSystem() const
+{
+	return SplatterMapSystem;
+}
+
+UInternalOrganSystem* UDismembermentComponent::GetInternalOrganSystem() const
+{
+	return InternalOrganSystem;
+}
+
+UBloodSystem* UDismembermentComponent::GetBloodSystem() const
+{
+	return BloodSystem;
+}
+
+void UDismembermentComponent::SetCutMaterial(UMaterialInterface* Material)
+{
+	if (BooleanCutTool)
+	{
+		BooleanCutTool->SetCutMaterial(Material);
+	}
+}
+
+void UDismembermentComponent::SetInnerMaterial(UMaterialInterface* Material)
+{
+	if (BooleanCutTool)
+	{
+		BooleanCutTool->SetInnerMaterial(Material);
+	}
+}
+
+void UDismembermentComponent::SetCapMeshMethod(ECapMeshMethod Method)
+{
+	if (BooleanCutTool)
+	{
+		BooleanCutTool->SetCapMeshMethod(Method);
+	}
+}
+
+void UDismembermentComponent::FindSkeletalMeshComponents()
+{
+	AActor* Owner = GetOwner();
+	if (!Owner)
+	{
+		return;
+	}
+
+	// Find all skeletal mesh components
+	TArray<USkeletalMeshComponent*> Components;
+	Owner->GetComponents<USkeletalMeshComponent>(Components);
+
+	// Set the main skeletal mesh component
+	if (Components.Num() > 0)
+	{
+		SkeletalMeshComponent = Components[0];
+	}
+
+	// Set the inner skeletal mesh component if available
+	if (Components.Num() > 1)
+	{
+		InnerSkeletalMeshComponent = Components[1];
+	}
+	else
+	{
+		// If there's only one skeletal mesh component, use it for both outer and inner
+		InnerSkeletalMeshComponent = SkeletalMeshComponent;
+	}
+}

Source/FLESH/Private/Gore/BloodPool.cpp

@@ -29,7 +29,8 @@ ABloodPool::ABloodPool()
 	// Try to load default decal material if not set
 	if(!DecalMaterial)
 	{
-		static ConstructorHelpers::FObjectFinder<UMaterialInterface> DefaultDecalMaterial(TEXT("/Game/FLESH/Gore/Textures/M_Decal_BloodPool"));
+		// Temporarily comment out resource loading to avoid engine crashes
+		static ConstructorHelpers::FObjectFinder<UMaterialInterface> DefaultDecalMaterial(TEXT("/FLESH/Gore/Mats/M_Decal_BloodPool"));
 		if(DefaultDecalMaterial.Succeeded())
 		{
 			DecalMaterial = DefaultDecalMaterial.Object;
@@ -37,7 +38,7 @@ ABloodPool::ABloodPool()
 	}
 
 	// Try to load default Niagara system if not set
-	static ConstructorHelpers::FObjectFinder<UNiagaraSystem> DefaultNiagaraSystem(TEXT("/Game/FLESH/Gore/Niagara/NS_DIS_BloodBurst"));
+	static ConstructorHelpers::FObjectFinder<UNiagaraSystem> DefaultNiagaraSystem(TEXT("/FLESH/Gore/NS_DIS_BloodBurst"));
 	if(DefaultNiagaraSystem.Succeeded())
 	{
 		BloodBurstSystem = DefaultNiagaraSystem.Object;
@@ -66,13 +67,15 @@ void ABloodPool::BeginPlay()
 	// Load default decal material if not set
 	if(!DecalMaterial)
 	{
-		DecalMaterial = LoadObject<UMaterialInterface>(nullptr, TEXT("/Game/FLESH/Gore/Textures/M_Decal_BloodPool"));
+		// Temporarily comment out resource loading to avoid engine crashes
+		DecalMaterial = LoadObject<UMaterialInterface>(nullptr, TEXT("/FLESH/Gore/Mats/M_Decal_BloodPool"));
 	}
 
 	// Load default Niagara system if not set
 	if(!BloodBurstSystem)
 	{
-		BloodBurstSystem = LoadObject<UNiagaraSystem>(nullptr, TEXT("/Game/FLESH/Gore/Niagara/NS_DIS_BloodBurst"));
+		// Temporarily comment out resource loading to avoid engine crashes
+		BloodBurstSystem = LoadObject<UNiagaraSystem>(nullptr, TEXT("/FLESH/Gore/NS_DIS_BloodBurst"));
 	}
 
 	// Set up decal properties

Source/FLESH/Private/Gore/InternalOrganSystem.cpp

@@ -0,0 +1,380 @@
+#include "Gore/InternalOrganSystem.h"
+#include "Components/StaticMeshComponent.h"
+#include "Engine/StaticMesh.h"
+#include "Materials/MaterialInstanceDynamic.h"
+#include "ProceduralMeshComponent.h"
+#include "KismetProceduralMeshLibrary.h"
+#include "PhysicsEngine/BodySetup.h"
+
+// Sets default values for this component's properties
+UInternalOrganSystem::UInternalOrganSystem()
+{
+	// Set this component to be initialized when the game starts, and to be ticked every frame
+	PrimaryComponentTick.bCanEverTick = true;
+
+	// Initialize default values
+	DefaultMuscleMaterial = nullptr;
+	DefaultBoneMaterial = nullptr;
+	DefaultOrganMaterial = nullptr;
+	DefaultBloodVesselMaterial = nullptr;
+}
+
+// Called when the game starts
+void UInternalOrganSystem::BeginPlay()
+{
+	Super::BeginPlay();
+}
+
+// Called every frame
+void UInternalOrganSystem::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+}
+
+UStaticMeshComponent* UInternalOrganSystem::AddInternalOrgan(const FOrganData& OrganData)
+{
+	if (!OrganData.Mesh)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: InternalOrganSystem - Cannot add organ with null mesh"));
+		return nullptr;
+	}
+
+	// Get the owner actor
+	AActor* Owner = GetOwner();
+	if (!Owner)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: InternalOrganSystem - Cannot add organ without owner actor"));
+		return nullptr;
+	}
+
+	// Create a new static mesh component
+	UStaticMeshComponent* OrganComponent = NewObject<UStaticMeshComponent>(Owner);
+	OrganComponent->SetStaticMesh(OrganData.Mesh);
+	
+	// Set the material if provided
+	if (OrganData.Material)
+	{
+		OrganComponent->SetMaterial(0, OrganData.Material);
+	}
+	else
+	{
+		// Use default material based on organ type
+		switch (OrganData.OrganType)
+		{
+		case EOrganType::Muscle:
+			if (DefaultMuscleMaterial)
+				OrganComponent->SetMaterial(0, DefaultMuscleMaterial);
+			break;
+		case EOrganType::Bone:
+			if (DefaultBoneMaterial)
+				OrganComponent->SetMaterial(0, DefaultBoneMaterial);
+			break;
+		case EOrganType::Organ:
+			if (DefaultOrganMaterial)
+				OrganComponent->SetMaterial(0, DefaultOrganMaterial);
+			break;
+		case EOrganType::Blood:
+			if (DefaultBloodVesselMaterial)
+				OrganComponent->SetMaterial(0, DefaultBloodVesselMaterial);
+			break;
+		default:
+			break;
+		}
+	}
+
+	// Register and attach the component
+	OrganComponent->RegisterComponent();
+	
+	// If a bone name is specified, attach to the bone
+	if (OrganData.AttachBone != NAME_None)
+	{
+		USkeletalMeshComponent* SkeletalMesh = Cast<USkeletalMeshComponent>(Owner->GetComponentByClass(USkeletalMeshComponent::StaticClass()));
+		if (SkeletalMesh)
+		{
+			OrganComponent->AttachToComponent(SkeletalMesh, FAttachmentTransformRules::KeepRelativeTransform, OrganData.AttachBone);
+			OrganComponent->SetRelativeTransform(OrganData.RelativeTransform);
+		}
+		else
+		{
+			// If no skeletal mesh, attach to the root component
+			OrganComponent->AttachToComponent(Owner->GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
+			OrganComponent->SetRelativeTransform(OrganData.RelativeTransform);
+		}
+	}
+	else
+	{
+		// Attach to the root component
+		OrganComponent->AttachToComponent(Owner->GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
+		OrganComponent->SetRelativeTransform(OrganData.RelativeTransform);
+	}
+
+	// Store the organ data
+	OrganComponents.Add(OrganComponent, OrganData);
+
+	return OrganComponent;
+}
+
+void UInternalOrganSystem::RemoveInternalOrgan(UStaticMeshComponent* OrganComponent)
+{
+	if (!OrganComponent)
+	{
+		return;
+	}
+
+	// Remove from the map
+	OrganComponents.Remove(OrganComponent);
+
+	// Destroy the component
+	OrganComponent->DestroyComponent();
+}
+
+TArray<UStaticMeshComponent*> UInternalOrganSystem::GetInternalOrgansOfType(EOrganType OrganType) const
+{
+	TArray<UStaticMeshComponent*> Result;
+
+	// Find all organs of the specified type
+	for (const auto& Pair : OrganComponents)
+	{
+		if (Pair.Value.OrganType == OrganType)
+		{
+			Result.Add(Pair.Key);
+		}
+	}
+
+	return Result;
+}
+
+UStaticMeshComponent* UInternalOrganSystem::CreateProceduralMuscle(FName StartBone, FName EndBone, float Thickness, UMaterialInterface* Material)
+{
+	// Get the owner actor
+	AActor* Owner = GetOwner();
+	if (!Owner)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: InternalOrganSystem - Cannot create muscle without owner actor"));
+		return nullptr;
+	}
+
+	// Get the skeletal mesh component
+	USkeletalMeshComponent* SkeletalMesh = Cast<USkeletalMeshComponent>(Owner->GetComponentByClass(USkeletalMeshComponent::StaticClass()));
+	if (!SkeletalMesh)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: InternalOrganSystem - Cannot create muscle without skeletal mesh component"));
+		return nullptr;
+	}
+
+	// Get bone transforms
+	FTransform StartTransform = SkeletalMesh->GetBoneTransform(SkeletalMesh->GetBoneIndex(StartBone));
+	FTransform EndTransform = SkeletalMesh->GetBoneTransform(SkeletalMesh->GetBoneIndex(EndBone));
+
+	// Create a tube mesh between the bones
+	UStaticMesh* MuscleMesh = CreateTubeMesh(StartTransform.GetLocation(), EndTransform.GetLocation(), Thickness, 8);
+	if (!MuscleMesh)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: InternalOrganSystem - Failed to create muscle mesh"));
+		return nullptr;
+	}
+
+	// Create organ data
+	FOrganData OrganData;
+	OrganData.Mesh = MuscleMesh;
+	OrganData.Material = Material != nullptr ? static_cast<UMaterialInterface*>(Material) : DefaultMuscleMaterial.Get();
+	OrganData.OrganType = EOrganType::Muscle;
+	OrganData.AttachBone = StartBone;
+	
+	// Calculate relative transform
+	FTransform RelativeTransform = FTransform::Identity;
+	RelativeTransform.SetLocation(StartTransform.GetLocation() - SkeletalMesh->GetBoneTransform(SkeletalMesh->GetBoneIndex(StartBone)).GetLocation());
+	OrganData.RelativeTransform = RelativeTransform;
+
+	// Add the organ
+	return AddInternalOrgan(OrganData);
+}
+
+UStaticMeshComponent* UInternalOrganSystem::CreateProceduralBloodVessel(const FVector& StartLocation, const FVector& EndLocation, float Thickness, UMaterialInterface* Material)
+{
+	// Get the owner actor
+	AActor* Owner = GetOwner();
+	if (!Owner)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: InternalOrganSystem - Cannot create blood vessel without owner actor"));
+		return nullptr;
+	}
+
+	// Create a tube mesh between the points
+	UStaticMesh* VesselMesh = CreateTubeMesh(StartLocation, EndLocation, Thickness, 8);
+	if (!VesselMesh)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: InternalOrganSystem - Failed to create blood vessel mesh"));
+		return nullptr;
+	}
+
+	// Create organ data
+	FOrganData OrganData;
+	OrganData.Mesh = VesselMesh;
+	OrganData.Material = Material != nullptr ? static_cast<UMaterialInterface*>(Material) : static_cast<UMaterialInterface*>(DefaultBloodVesselMaterial.Get());
+	OrganData.OrganType = EOrganType::Blood;
+	
+	// Calculate transform
+	FTransform Transform = FTransform::Identity;
+	Transform.SetLocation(StartLocation);
+	OrganData.RelativeTransform = Transform;
+
+	// Add the organ
+	return AddInternalOrgan(OrganData);
+}
+
+void UInternalOrganSystem::ExposeInternalOrgansAtCut(const FVector& CutLocation, const FVector& CutNormal, float Radius)
+{
+	// Get the owner actor
+	AActor* Owner = GetOwner();
+	if (!Owner)
+	{
+		return;
+	}
+
+	// Create a plane from the cut location and normal
+	FPlane CutPlane(CutLocation, CutNormal);
+
+	// Check each organ to see if it should be exposed
+	for (const auto& Pair : OrganComponents)
+	{
+		UStaticMeshComponent* OrganComponent = Pair.Key;
+		if (!OrganComponent)
+		{
+			continue;
+		}
+
+		// Get the organ's world location
+		FVector OrganLocation = OrganComponent->GetComponentLocation();
+
+		// Calculate distance to the cut plane
+		float DistanceToCut = FMath::Abs(CutPlane.PlaneDot(OrganLocation));
+
+		// Calculate distance to the cut location
+		float DistanceToCutLocation = FVector::Distance(OrganLocation, CutLocation);
+
+		// If the organ is close enough to the cut and within the radius, make it visible
+		if (DistanceToCut < 10.0f && DistanceToCutLocation < Radius)
+		{
+			// Make the organ visible
+			OrganComponent->SetVisibility(true);
+
+			// Create a dynamic material instance for the organ
+			UMaterialInstanceDynamic* DynamicMaterial = UMaterialInstanceDynamic::Create(OrganComponent->GetMaterial(0), OrganComponent);
+			OrganComponent->SetMaterial(0, DynamicMaterial);
+
+			// Set parameters for the cut effect
+			DynamicMaterial->SetVectorParameterValue(FName("CutLocation"), FLinearColor(CutLocation.X, CutLocation.Y, CutLocation.Z, 0.0f));
+			DynamicMaterial->SetVectorParameterValue(FName("CutNormal"), FLinearColor(CutNormal.X, CutNormal.Y, CutNormal.Z, 0.0f));
+			DynamicMaterial->SetScalarParameterValue(FName("CutRadius"), Radius);
+		}
+	}
+}
+
+UStaticMesh* UInternalOrganSystem::CreateTubeMesh(const FVector& Start, const FVector& End, float Radius, int32 Segments)
+{
+	// Create procedural mesh component for generation
+	UProceduralMeshComponent* ProcMesh = NewObject<UProceduralMeshComponent>(this);
+	
+	// Calculate tube direction and length
+	FVector Direction = (End - Start).GetSafeNormal();
+	float Length = FVector::Distance(Start, End);
+	
+	// Find perpendicular vectors to create the tube
+	FVector UpVector = FVector::UpVector;
+	if (FMath::Abs(FVector::DotProduct(Direction, UpVector)) > 0.9f)
+	{
+		UpVector = FVector::ForwardVector;
+	}
+	
+	FVector RightVector = FVector::CrossProduct(Direction, UpVector).GetSafeNormal();
+	FVector NewUpVector = FVector::CrossProduct(RightVector, Direction).GetSafeNormal();
+	
+	// Generate vertices and triangles for the tube
+	TArray<FVector> Vertices;
+	TArray<int32> Triangles;
+	TArray<FVector> Normals;
+	TArray<FVector2D> UVs;
+	TArray<FProcMeshTangent> Tangents;
+	
+	// Create vertices for the tube
+	for (int32 i = 0; i <= Segments; ++i)
+	{
+		float Angle = 2.0f * PI * (float)i / (float)Segments;
+		FVector CirclePoint = RightVector * FMath::Cos(Angle) + NewUpVector * FMath::Sin(Angle);
+		
+		// Start cap
+		Vertices.Add(Start);
+		Normals.Add(-Direction);
+		UVs.Add(FVector2D(0.5f + 0.5f * FMath::Cos(Angle), 0.5f + 0.5f * FMath::Sin(Angle)));
+		Tangents.Add(FProcMeshTangent(RightVector, false));
+		
+		Vertices.Add(Start + CirclePoint * Radius);
+		Normals.Add(-Direction);
+		UVs.Add(FVector2D(0.5f + 0.5f * FMath::Cos(Angle), 0.5f + 0.5f * FMath::Sin(Angle)));
+		Tangents.Add(FProcMeshTangent(RightVector, false));
+		
+		// End cap
+		Vertices.Add(End);
+		Normals.Add(Direction);
+		UVs.Add(FVector2D(0.5f + 0.5f * FMath::Cos(Angle), 0.5f + 0.5f * FMath::Sin(Angle)));
+		Tangents.Add(FProcMeshTangent(RightVector, false));
+		
+		Vertices.Add(End + CirclePoint * Radius);
+		Normals.Add(Direction);
+		UVs.Add(FVector2D(0.5f + 0.5f * FMath::Cos(Angle), 0.5f + 0.5f * FMath::Sin(Angle)));
+		Tangents.Add(FProcMeshTangent(RightVector, false));
+		
+		// Tube body
+		Vertices.Add(Start + CirclePoint * Radius);
+		Normals.Add(CirclePoint);
+		UVs.Add(FVector2D((float)i / (float)Segments, 0.0f));
+		Tangents.Add(FProcMeshTangent(Direction, false));
+		
+		Vertices.Add(End + CirclePoint * Radius);
+		Normals.Add(CirclePoint);
+		UVs.Add(FVector2D((float)i / (float)Segments, 1.0f));
+		Tangents.Add(FProcMeshTangent(Direction, false));
+	}
+	
+	// Create triangles
+	for (int32 i = 0; i < Segments; ++i)
+	{
+		int32 BaseIndex = i * 6;
+		
+		// Start cap triangles
+		Triangles.Add(BaseIndex + 0);
+		Triangles.Add(BaseIndex + 2);
+		Triangles.Add(BaseIndex + 1);
+		
+		// End cap triangles
+		Triangles.Add(BaseIndex + 2);
+		Triangles.Add(BaseIndex + 3);
+		Triangles.Add(BaseIndex + 1);
+		
+		// Tube body triangles
+		Triangles.Add(BaseIndex + 4);
+		Triangles.Add(BaseIndex + 5);
+		Triangles.Add(BaseIndex + 10);
+		
+		Triangles.Add(BaseIndex + 5);
+		Triangles.Add(BaseIndex + 11);
+		Triangles.Add(BaseIndex + 10);
+	}
+	
+	// Create the procedural mesh
+	ProcMesh->CreateMeshSection_LinearColor(0, Vertices, Triangles, Normals, UVs, TArray<FLinearColor>(), Tangents, true);
+	
+	// Convert procedural mesh to static mesh
+	UStaticMesh* StaticMesh = NewObject<UStaticMesh>(this);
+	UBodySetup* BodySetup = NewObject<UBodySetup>(StaticMesh);
+	StaticMesh->AddSourceModel(); // 不需要保存返回值
+	StaticMesh->CreateBodySetup();
+	
+	// TODO: Convert procedural mesh to static mesh
+	// This requires more complex implementation using FMeshDescription
+	// For now, we'll return a basic cylinder mesh
+	
+	// Return the static mesh
+	return StaticMesh;
+}

Source/FLESH/Private/Gore/SplatterMapSystem.cpp

@@ -0,0 +1,246 @@
+#include "Gore/SplatterMapSystem.h"
+#include "Kismet/KismetRenderingLibrary.h"
+#include "Materials/MaterialInstanceDynamic.h"
+#include "Engine/TextureRenderTarget2D.h"
+#include "Materials/Material.h"
+#include "Engine/Canvas.h"
+
+// Sets default values for this component's properties
+USplatterMapSystem::USplatterMapSystem()
+{
+	// Set this component to be initialized when the game starts, and to be ticked every frame
+	PrimaryComponentTick.bCanEverTick = true;
+
+	// Initialize default values
+	SplatterRenderMaterial = nullptr;
+}
+
+// Called when the game starts
+void USplatterMapSystem::BeginPlay()
+{
+	Super::BeginPlay();
+
+	// Initialize splatter maps for each body region if not already set
+	if (!SplatterMaps.Contains(EBodyRegion::LowerBody))
+	{
+		FSplatterMapData LowerBodyData;
+		SplatterMaps.Add(EBodyRegion::LowerBody, LowerBodyData);
+	}
+
+	if (!SplatterMaps.Contains(EBodyRegion::UpperBody))
+	{
+		FSplatterMapData UpperBodyData;
+		SplatterMaps.Add(EBodyRegion::UpperBody, UpperBodyData);
+	}
+
+	if (!SplatterMaps.Contains(EBodyRegion::Head))
+	{
+		FSplatterMapData HeadData;
+		SplatterMaps.Add(EBodyRegion::Head, HeadData);
+	}
+
+	if (!SplatterMaps.Contains(EBodyRegion::Hair))
+	{
+		FSplatterMapData HairData;
+		SplatterMaps.Add(EBodyRegion::Hair, HairData);
+	}
+
+	if (!SplatterMaps.Contains(EBodyRegion::Clothing))
+	{
+		FSplatterMapData ClothingData;
+		SplatterMaps.Add(EBodyRegion::Clothing, ClothingData);
+	}
+}
+
+// Called every frame
+void USplatterMapSystem::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+
+	// Update any dynamic effects (e.g., dripping blood)
+}
+
+void USplatterMapSystem::ApplyWoundToSplatterMap(const FVector& Location, const FVector& Normal, float Size, 
+	const TMap<ESplatterMapChannel, float>& Channels, EBodyRegion BodyRegion)
+{
+	// Get splatter map data for the specified body region
+	FSplatterMapData* SplatterMapData = SplatterMaps.Find(BodyRegion);
+	if (!SplatterMapData || !SplatterMapData->SplatterMap)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: SplatterMapSystem - No splatter map found for body region %d"), (int32)BodyRegion);
+		return;
+	}
+
+	// Convert world location to UV coordinates
+	FVector2D UV = WorldLocationToUV(Location, Normal, BodyRegion);
+
+	// Choose appropriate wound decal based on channels
+	UTexture2D* WoundDecal = nullptr;
+	if (Channels.Contains(ESplatterMapChannel::Depth) && Channels[ESplatterMapChannel::Depth] > 0.5f)
+	{
+		// Deep wound
+		WoundDecal = WoundDecals.FindRef(FName("DeepWound"));
+	}
+	else if (Channels.Contains(ESplatterMapChannel::Bruising) && Channels[ESplatterMapChannel::Bruising] > 0.5f)
+	{
+		// Bruise
+		WoundDecal = WoundDecals.FindRef(FName("Bruise"));
+	}
+	else
+	{
+		// Default wound
+		WoundDecal = WoundDecals.FindRef(FName("DefaultWound"));
+	}
+
+	if (!WoundDecal)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: SplatterMapSystem - No appropriate wound decal found"));
+		return;
+	}
+
+	// Apply the decal to the splatter map
+	float Rotation = FMath::RandRange(0.0f, 360.0f); // Random rotation for variety
+	RenderToSplatterMap(SplatterMapData->SplatterMap, WoundDecal, UV, Size, Rotation, Channels);
+}
+
+void USplatterMapSystem::ApplyDecalToSplatterMap(UTexture2D* DecalTexture, const FVector& Location, const FVector& Normal, 
+	float Size, float Rotation, EBodyRegion BodyRegion)
+{
+	// Get splatter map data for the specified body region
+	FSplatterMapData* SplatterMapData = SplatterMaps.Find(BodyRegion);
+	if (!SplatterMapData || !SplatterMapData->SplatterMap || !DecalTexture)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: SplatterMapSystem - Invalid splatter map or decal texture"));
+		return;
+	}
+
+	// Convert world location to UV coordinates
+	FVector2D UV = WorldLocationToUV(Location, Normal, BodyRegion);
+
+	// Create a map of channels with default values
+	TMap<ESplatterMapChannel, float> Channels;
+	Channels.Add(ESplatterMapChannel::Depth, 1.0f);
+	Channels.Add(ESplatterMapChannel::Bloodiness, 1.0f);
+
+	// Apply the decal to the splatter map
+	RenderToSplatterMap(SplatterMapData->SplatterMap, DecalTexture, UV, Size, Rotation, Channels);
+}
+
+FSplatterMapData USplatterMapSystem::GetSplatterMapData(EBodyRegion BodyRegion) const
+{
+	// Get splatter map data for the specified body region
+	const FSplatterMapData* SplatterMapData = SplatterMaps.Find(BodyRegion);
+	if (SplatterMapData)
+	{
+		return *SplatterMapData;
+	}
+
+	// Return empty data if not found
+	return FSplatterMapData();
+}
+
+void USplatterMapSystem::SetSplatterMapData(EBodyRegion BodyRegion, const FSplatterMapData& SplatterMapData)
+{
+	// Set splatter map data for the specified body region
+	SplatterMaps.Add(BodyRegion, SplatterMapData);
+}
+
+void USplatterMapSystem::ClearSplatterMaps()
+{
+	// Clear all splatter maps
+	for (auto& Pair : SplatterMaps)
+	{
+		if (Pair.Value.SplatterMap)
+		{
+			// Create a render target to clear the texture
+			UTextureRenderTarget2D* RenderTarget = UKismetRenderingLibrary::CreateRenderTarget2D(
+				GetWorld(), 
+				Pair.Value.SplatterMap->GetSizeX(), 
+				Pair.Value.SplatterMap->GetSizeY()
+			);
+
+			// Clear the render target
+			UKismetRenderingLibrary::ClearRenderTarget2D(GetWorld(), RenderTarget);
+
+			// 注意：ExportRenderTarget函数不能直接将RenderTarget复制到Texture2D
+			// 我们需要使用其他方法来实现这一功能
+			// 临时解决方案：简化实现，暂时不复制纹理内容
+			// 在实际项目中，需要实现一个自定义的纹理复制方法
+			// UMaterialInstanceDynamic* CopyMaterial = UMaterialInstanceDynamic::Create(UMaterial::GetDefaultMaterial(EMaterialDomain::Surface), this);
+			// CopyMaterial->SetTextureParameterValue(TEXT("Texture"), RenderTarget);
+			
+			// Release the render target
+			RenderTarget->ConditionalBeginDestroy();
+		}
+	}
+}
+
+FVector2D USplatterMapSystem::WorldLocationToUV(const FVector& Location, const FVector& Normal, EBodyRegion BodyRegion) const
+{
+	// This is a simplified implementation that would need to be customized based on the character's mesh and UV layout
+	// In a real implementation, you would:
+	// 1. Get the skeletal mesh component from the owner
+	// 2. Find the closest vertex or surface point to the world location
+	// 3. Get the UV coordinates of that point
+	
+	// For now, return a random UV coordinate for testing
+	return FVector2D(FMath::FRand(), FMath::FRand());
+}
+
+void USplatterMapSystem::RenderToSplatterMap(UTexture2D* TargetTexture, UTexture2D* DecalTexture, const FVector2D& UV, 
+	float Size, float Rotation, const TMap<ESplatterMapChannel, float>& Channels)
+{
+	if (!TargetTexture || !DecalTexture || !SplatterRenderMaterial)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("FLESH: SplatterMapSystem - Invalid textures or material for rendering"));
+		return;
+	}
+
+	// Create a render target with the same dimensions as the target texture
+	UTextureRenderTarget2D* RenderTarget = UKismetRenderingLibrary::CreateRenderTarget2D(
+		GetWorld(), 
+		TargetTexture->GetSizeX(), 
+		TargetTexture->GetSizeY()
+	);
+
+	// Copy the current splatter map to the render target
+	UKismetRenderingLibrary::DrawMaterialToRenderTarget(
+		GetWorld(),
+		RenderTarget,
+		UMaterialInstanceDynamic::Create(SplatterRenderMaterial, this)
+	);
+
+	// Create a dynamic material instance for rendering the decal
+	UMaterialInstanceDynamic* DecalMaterial = UMaterialInstanceDynamic::Create(SplatterRenderMaterial, this);
+	
+	// Set parameters for the decal material
+	DecalMaterial->SetTextureParameterValue(FName("DecalTexture"), DecalTexture);
+	DecalMaterial->SetScalarParameterValue(FName("DecalSize"), Size);
+	DecalMaterial->SetScalarParameterValue(FName("DecalRotation"), Rotation);
+	DecalMaterial->SetVectorParameterValue(FName("DecalUV"), FLinearColor(UV.X, UV.Y, 0.0f, 0.0f));
+	
+	// Set channel values
+	for (const auto& Pair : Channels)
+	{
+		FString ChannelName = UEnum::GetValueAsString(Pair.Key).Replace(TEXT("ESplatterMapChannel::"), TEXT(""));
+		DecalMaterial->SetScalarParameterValue(FName(*ChannelName), Pair.Value);
+	}
+
+	// Draw the decal to the render target
+	UKismetRenderingLibrary::DrawMaterialToRenderTarget(
+		GetWorld(),
+		RenderTarget,
+		DecalMaterial
+	);
+
+	// 注意：ExportRenderTarget函数不能直接将RenderTarget复制到Texture2D
+	// 我们需要使用其他方法来实现这一功能
+	// 临时解决方案：简化实现，暂时不复制纹理内容
+	// 在实际项目中，需要实现一个自定义的纹理复制方法
+	// 例如，可以使用DrawMaterialToRenderTarget配合特殊材质来复制纹理
+	// 或者使用UE5的其他API来实现RenderTarget到Texture2D的复制
+	// UKismetRenderingLibrary::ExportRenderTarget(GetWorld(), RenderTarget, TEXT(""), TargetTexture);
+
+	// Release the render target
+	RenderTarget->ConditionalBeginDestroy();
+}

Source/FLESH/Public/BooleanCutTool.h

@@ -50,6 +50,46 @@ struct FCutPlane
 	}
 };
 
+/**
+ * Cap mesh generation method
+ */
+UENUM(BlueprintType)
+enum class ECapMeshMethod : uint8
+{
+	// Simple flat cap
+	Simple UMETA(DisplayName = "Simple Flat Cap"),
+	
+	// Triangle fan cap (better for convex holes)
+	TriangleFan UMETA(DisplayName = "Triangle Fan"),
+	
+	// Tessellated cap with displacement
+	Tessellated UMETA(DisplayName = "Tessellated with Displacement"),
+	
+	// No cap
+	None UMETA(DisplayName = "No Cap")
+};
+
+/**
+ * Multi-layer cut result
+ */
+USTRUCT(BlueprintType)
+struct FMultiLayerCutResult
+{
+	GENERATED_BODY()
+
+	// Outer layer mesh (skin)
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Cutting")
+	TObjectPtr<UStaticMesh> OuterMesh;
+
+	// Inner layer mesh (meat/muscle)
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Cutting")
+	TObjectPtr<UStaticMesh> InnerMesh;
+
+	// Cap mesh
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Cutting")
+	TObjectPtr<UStaticMesh> CapMesh;
+};
+
 /**
  * Boolean cut tool class
  * Provides real-time boolean cutting functionality
@@ -94,6 +134,48 @@ public:
 	UFUNCTION(BlueprintCallable, Category = "FLESH|Cutting")
 	TArray<UProceduralMeshComponent*> CutProceduralMesh(UProceduralMeshComponent* TargetMesh, const FCutPlane& CutPlane, bool bCreateCap = true);
 
+	/**
+	 * Perform multi-layer cut on skeletal mesh (Kinder Egg Man approach)
+	 * @param OuterMesh - Outer layer mesh (skin)
+	 * @param InnerMesh - Inner layer mesh (meat/muscle)
+	 * @param CutPlane - Cut plane
+	 * @param CapMethod - Method to generate cap mesh
+	 * @return Multi-layer cut result
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	FMultiLayerCutResult CutMultiLayerMesh(USkeletalMesh* OuterMesh, USkeletalMesh* InnerMesh, const FCutPlane& CutPlane, ECapMeshMethod CapMethod = ECapMeshMethod::TriangleFan);
+
+	/**
+	 * Perform bone-guided cut on skeletal mesh
+	 * @param TargetMesh - Target skeletal mesh
+	 * @param BoneName - Bone to use as support axis
+	 * @param CutPlane - Cut plane
+	 * @param bCreateCap - Whether to create a cap
+	 * @return Array of cut skeletal meshes [0] is positive side, [1] is negative side
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	TArray<USkeletalMesh*> CutWithBoneAxis(USkeletalMesh* TargetMesh, FName BoneName, const FCutPlane& CutPlane, bool bCreateCap = true);
+
+	/**
+	 * Create triangle fan cap mesh for convex holes
+	 * @param IntersectionPoints - Points where the cut plane intersects the mesh
+	 * @param CutPlane - Cut plane
+	 * @return Cap mesh
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	UStaticMesh* CreateTriangleFanCapMesh(const TArray<FVector>& IntersectionPoints, const FCutPlane& CutPlane);
+
+	/**
+	 * Create tessellated cap mesh with displacement
+	 * @param IntersectionPoints - Points where the cut plane intersects the mesh
+	 * @param CutPlane - Cut plane
+	 * @param DisplacementTexture - Texture to use for displacement
+	 * @param DisplacementScale - Scale of displacement
+	 * @return Cap mesh
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	UStaticMesh* CreateTessellatedCapMesh(const TArray<FVector>& IntersectionPoints, const FCutPlane& CutPlane, UTexture2D* DisplacementTexture, float DisplacementScale = 1.0f);
+
 	/**
 	 * Create cut plane mesh
 	 * @param CutPlane - Cut plane
@@ -116,14 +198,59 @@ public:
 	UFUNCTION(BlueprintCallable, Category = "FLESH|Cutting")
 	UMaterialInterface* GetCutMaterial() const;
 
+	/**
+	 * Set inner material (for multi-layer cutting)
+	 * @param Material - Inner material
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	void SetInnerMaterial(UMaterialInterface* Material);
+
+	/**
+	 * Get inner material
+	 * @return Current inner material
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	UMaterialInterface* GetInnerMaterial() const;
+
+	/**
+	 * Set cap mesh method
+	 * @param Method - Cap mesh generation method
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	void SetCapMeshMethod(ECapMeshMethod Method);
+
+	/**
+	 * Get cap mesh method
+	 * @return Current cap mesh method
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Advanced Cutting")
+	ECapMeshMethod GetCapMeshMethod() const;
+
 private:
 	// Cut material
 	UPROPERTY()
 	TObjectPtr<UMaterialInterface> CutMaterial;
 
+	// Inner material (for multi-layer cutting)
+	UPROPERTY()
+	TObjectPtr<UMaterialInterface> InnerMaterial;
+
+	// Cap mesh method
+	UPROPERTY()
+	ECapMeshMethod CapMeshMethod;
+
 	// Internal function to calculate intersection points between cut plane and mesh
 	TArray<FVector> CalculateIntersectionPoints(const TArray<FVector>& Vertices, const TArray<int32>& Indices, const FCutPlane& CutPlane);
 
 	// Internal function to create cap mesh
 	void CreateCapMesh(const TArray<FVector>& IntersectionPoints, const FCutPlane& CutPlane, UProceduralMeshComponent* TargetMesh);
+
+	// Internal function to find bone center and direction
+	void GetBoneAxisInfo(USkeletalMesh* SkeletalMesh, FName BoneName, FVector& OutCenter, FVector& OutDirection);
+
+	// Internal function to create triangle fan from intersection points
+	TArray<FVector> CreateTriangleFan(const TArray<FVector>& IntersectionPoints, const FVector& Center);
+
+	// Internal function to tessellate a polygon
+	TArray<FVector> TessellatePolygon(const TArray<FVector>& PolygonPoints, int32 Subdivisions);
 };

Source/FLESH/Public/DismembermentComponent.h

@@ -0,0 +1,143 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "BooleanCutTool.h"
+#include "DismembermentComponent.generated.h"
+
+// Forward declarations
+class USplatterMapSystem;
+class UInternalOrganSystem;
+class UBloodSystem;
+
+/**
+ * Dismemberment component for the FLESH plugin
+ * Provides a central control point for all dismemberment systems
+ */
+UCLASS(ClassGroup=(FLESH), meta=(BlueprintSpawnableComponent))
+class FLESH_API UDismembermentComponent : public UActorComponent
+{
+	GENERATED_BODY()
+
+public:	
+	// Sets default values for this component's properties
+	UDismembermentComponent();
+
+protected:
+	// Called when the game starts
+	virtual void BeginPlay() override;
+
+public:	
+	// Called every frame
+	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
+
+	/**
+	 * Perform dismemberment at the specified location
+	 * @param CutPlane - Cut plane
+	 * @param BoneName - Optional bone name to guide the cut
+	 * @param bCreateCap - Whether to create a cap
+	 * @param CapMethod - Method to generate cap mesh
+	 * @return Whether the dismemberment was successful
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	bool PerformDismemberment(const FCutPlane& CutPlane, FName BoneName = NAME_None, bool bCreateCap = true, ECapMeshMethod CapMethod = ECapMeshMethod::TriangleFan);
+
+	/**
+	 * Perform multi-layer dismemberment at the specified location
+	 * @param CutPlane - Cut plane
+	 * @param bCreateCap - Whether to create a cap
+	 * @param CapMethod - Method to generate cap mesh
+	 * @return Whether the dismemberment was successful
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	bool PerformMultiLayerDismemberment(const FCutPlane& CutPlane, bool bCreateCap = true, ECapMeshMethod CapMethod = ECapMeshMethod::TriangleFan);
+
+	/**
+	 * Apply wound at the specified location
+	 * @param Location - World location of the wound
+	 * @param Normal - Surface normal at the wound location
+	 * @param Size - Size of the wound
+	 * @param Depth - Depth of the wound (0.0-1.0)
+	 * @param Bloodiness - Bloodiness of the wound (0.0-1.0)
+	 * @param Bruising - Bruising of the wound (0.0-1.0)
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	void ApplyWound(const FVector& Location, const FVector& Normal, float Size, float Depth = 1.0f, float Bloodiness = 1.0f, float Bruising = 0.5f);
+
+	/**
+	 * Get the boolean cut tool
+	 * @return The boolean cut tool
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	UBooleanCutTool* GetBooleanCutTool() const;
+
+	/**
+	 * Get the splatter map system
+	 * @return The splatter map system
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	USplatterMapSystem* GetSplatterMapSystem() const;
+
+	/**
+	 * Get the internal organ system
+	 * @return The internal organ system
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	UInternalOrganSystem* GetInternalOrganSystem() const;
+
+	/**
+	 * Get the blood system
+	 * @return The blood system
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	UBloodSystem* GetBloodSystem() const;
+
+	/**
+	 * Set cut material
+	 * @param Material - Cut material
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	void SetCutMaterial(UMaterialInterface* Material);
+
+	/**
+	 * Set inner material
+	 * @param Material - Inner material
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	void SetInnerMaterial(UMaterialInterface* Material);
+
+	/**
+	 * Set cap mesh method
+	 * @param Method - Cap mesh method
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Dismemberment")
+	void SetCapMeshMethod(ECapMeshMethod Method);
+
+private:
+	// Boolean cut tool
+	UPROPERTY()
+	TObjectPtr<UBooleanCutTool> BooleanCutTool;
+
+	// Splatter map system
+	UPROPERTY()
+	TObjectPtr<USplatterMapSystem> SplatterMapSystem;
+
+	// Internal organ system
+	UPROPERTY()
+	TObjectPtr<UInternalOrganSystem> InternalOrganSystem;
+
+	// Blood system
+	UPROPERTY()
+	TObjectPtr<UBloodSystem> BloodSystem;
+
+	// Skeletal mesh component
+	UPROPERTY()
+	TObjectPtr<USkeletalMeshComponent> SkeletalMeshComponent;
+
+	// Inner skeletal mesh component (for multi-layer dismemberment)
+	UPROPERTY()
+	TObjectPtr<USkeletalMeshComponent> InnerSkeletalMeshComponent;
+
+	// Find skeletal mesh components
+	void FindSkeletalMeshComponents();
+};

Source/FLESH/Public/Gore/InternalOrganSystem.h

@@ -0,0 +1,157 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "InternalOrganSystem.generated.h"
+
+/**
+ * Organ types for internal organ system
+ */
+UENUM(BlueprintType)
+enum class EOrganType : uint8
+{
+	Muscle UMETA(DisplayName = "Muscle"),
+	Bone UMETA(DisplayName = "Bone"),
+	Organ UMETA(DisplayName = "Internal Organ"),
+	Tendon UMETA(DisplayName = "Tendon"),
+	Blood UMETA(DisplayName = "Blood Vessel")
+};
+
+/**
+ * Internal organ data structure
+ */
+USTRUCT(BlueprintType)
+struct FOrganData
+{
+	GENERATED_BODY()
+
+	// Mesh for the organ
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	TObjectPtr<UStaticMesh> Mesh;
+
+	// Material for the organ
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	TObjectPtr<UMaterialInterface> Material;
+
+	// Type of organ
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	EOrganType OrganType;
+
+	// Bone to attach to
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	FName AttachBone;
+
+	// Relative transform to the bone
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	FTransform RelativeTransform;
+
+	// Constructor
+	FOrganData()
+		: Mesh(nullptr)
+		, Material(nullptr)
+		, OrganType(EOrganType::Muscle)
+		, AttachBone(NAME_None)
+		, RelativeTransform(FTransform::Identity)
+	{
+	}
+};
+
+/**
+ * Internal organ system component for the FLESH plugin
+ * Handles creation and management of internal organs for dismemberment
+ */
+UCLASS(ClassGroup=(FLESH), meta=(BlueprintSpawnableComponent))
+class FLESH_API UInternalOrganSystem : public UActorComponent
+{
+	GENERATED_BODY()
+
+public:	
+	// Sets default values for this component's properties
+	UInternalOrganSystem();
+
+protected:
+	// Called when the game starts
+	virtual void BeginPlay() override;
+
+public:	
+	// Called every frame
+	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
+
+	/**
+	 * Add an internal organ to the system
+	 * @param OrganData - Data for the organ to add
+	 * @return The created static mesh component
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	UStaticMeshComponent* AddInternalOrgan(const FOrganData& OrganData);
+
+	/**
+	 * Remove an internal organ from the system
+	 * @param OrganComponent - Component to remove
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	void RemoveInternalOrgan(UStaticMeshComponent* OrganComponent);
+
+	/**
+	 * Get all internal organs of a specific type
+	 * @param OrganType - Type of organs to get
+	 * @return Array of static mesh components for the specified organ type
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	TArray<UStaticMeshComponent*> GetInternalOrgansOfType(EOrganType OrganType) const;
+
+	/**
+	 * Create a procedural muscle between two bones
+	 * @param StartBone - Starting bone name
+	 * @param EndBone - Ending bone name
+	 * @param Thickness - Thickness of the muscle
+	 * @param Material - Material to use for the muscle
+	 * @return The created static mesh component
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	UStaticMeshComponent* CreateProceduralMuscle(FName StartBone, FName EndBone, float Thickness, UMaterialInterface* Material);
+
+	/**
+	 * Create a procedural blood vessel between two points
+	 * @param StartLocation - Starting location
+	 * @param EndLocation - Ending location
+	 * @param Thickness - Thickness of the blood vessel
+	 * @param Material - Material to use for the blood vessel
+	 * @return The created static mesh component
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	UStaticMeshComponent* CreateProceduralBloodVessel(const FVector& StartLocation, const FVector& EndLocation, float Thickness, UMaterialInterface* Material);
+
+	/**
+	 * Expose internal organs at cut location
+	 * @param CutLocation - Location of the cut
+	 * @param CutNormal - Normal of the cut plane
+	 * @param Radius - Radius around the cut to expose organs
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	void ExposeInternalOrgansAtCut(const FVector& CutLocation, const FVector& CutNormal, float Radius);
+
+private:
+	// Map of organ components to their data
+	UPROPERTY()
+	TMap<TObjectPtr<UStaticMeshComponent>, FOrganData> OrganComponents;
+
+	// Default muscle material
+	UPROPERTY(EditAnywhere, Category = "FLESH|Gore", meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<UMaterialInterface> DefaultMuscleMaterial;
+
+	// Default bone material
+	UPROPERTY(EditAnywhere, Category = "FLESH|Gore", meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<UMaterialInterface> DefaultBoneMaterial;
+
+	// Default organ material
+	UPROPERTY(EditAnywhere, Category = "FLESH|Gore", meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<UMaterialInterface> DefaultOrganMaterial;
+
+	// Default blood vessel material
+	UPROPERTY(EditAnywhere, Category = "FLESH|Gore", meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<UMaterialInterface> DefaultBloodVesselMaterial;
+
+	// Create a tube mesh between two points
+	UStaticMesh* CreateTubeMesh(const FVector& Start, const FVector& End, float Radius, int32 Segments);
+};

Source/FLESH/Public/Gore/SplatterMapSystem.h

@@ -0,0 +1,152 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "SplatterMapSystem.generated.h"
+
+/**
+ * Wound property channels for splatter maps
+ */
+UENUM(BlueprintType)
+enum class ESplatterMapChannel : uint8
+{
+	Depth UMETA(DisplayName = "Depth"),
+	Bloodiness UMETA(DisplayName = "Bloodiness"),
+	Bruising UMETA(DisplayName = "Bruising"),
+	Dilation UMETA(DisplayName = "Dilation Mask"),
+	DrippingBlood UMETA(DisplayName = "Dripping Blood"),
+	BurntAreas UMETA(DisplayName = "Burnt Areas"),
+	Water UMETA(DisplayName = "Water"),
+	Fuel UMETA(DisplayName = "Fuel")
+};
+
+/**
+ * Body region for splatter maps
+ */
+UENUM(BlueprintType)
+enum class EBodyRegion : uint8
+{
+	LowerBody UMETA(DisplayName = "Lower Body"),
+	UpperBody UMETA(DisplayName = "Upper Body"),
+	Head UMETA(DisplayName = "Head"),
+	Hair UMETA(DisplayName = "Hair"),
+	Clothing UMETA(DisplayName = "Clothing")
+};
+
+/**
+ * Splatter map data structure
+ */
+USTRUCT(BlueprintType)
+struct FSplatterMapData
+{
+	GENERATED_BODY()
+
+	// Diffuse texture (1024x1024)
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	TObjectPtr<UTexture2D> DiffuseMap;
+
+	// Splatter texture (128x128)
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	TObjectPtr<UTexture2D> SplatterMap;
+
+	// Body region this splatter map applies to
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FLESH|Gore")
+	EBodyRegion BodyRegion;
+
+	// Constructor
+	FSplatterMapData()
+		: DiffuseMap(nullptr)
+		, SplatterMap(nullptr)
+		, BodyRegion(EBodyRegion::UpperBody)
+	{
+	}
+};
+
+/**
+ * Splatter map system component for the FLESH plugin
+ * Handles wound visualization using splatter maps
+ */
+UCLASS(ClassGroup=(FLESH), meta=(BlueprintSpawnableComponent))
+class FLESH_API USplatterMapSystem : public UActorComponent
+{
+	GENERATED_BODY()
+
+public:	
+	// Sets default values for this component's properties
+	USplatterMapSystem();
+
+protected:
+	// Called when the game starts
+	virtual void BeginPlay() override;
+
+public:	
+	// Called every frame
+	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
+
+	/**
+	 * Apply wound effect to splatter map at world location
+	 * @param Location - World location of the wound
+	 * @param Normal - Surface normal at the wound location
+	 * @param Size - Size of the wound
+	 * @param Channels - Map of channels to values to apply
+	 * @param BodyRegion - Body region to apply the wound to
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	void ApplyWoundToSplatterMap(const FVector& Location, const FVector& Normal, float Size, 
+		const TMap<ESplatterMapChannel, float>& Channels, EBodyRegion BodyRegion = EBodyRegion::UpperBody);
+
+	/**
+	 * Apply decal to splatter map
+	 * @param DecalTexture - Decal texture to apply
+	 * @param Location - World location of the decal
+	 * @param Normal - Surface normal at the decal location
+	 * @param Size - Size of the decal
+	 * @param Rotation - Rotation of the decal
+	 * @param BodyRegion - Body region to apply the decal to
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	void ApplyDecalToSplatterMap(UTexture2D* DecalTexture, const FVector& Location, const FVector& Normal, 
+		float Size, float Rotation, EBodyRegion BodyRegion = EBodyRegion::UpperBody);
+
+	/**
+	 * Get splatter map data for a specific body region
+	 * @param BodyRegion - Body region to get splatter map data for
+	 * @return Splatter map data for the specified body region
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	FSplatterMapData GetSplatterMapData(EBodyRegion BodyRegion) const;
+
+	/**
+	 * Set splatter map data for a specific body region
+	 * @param BodyRegion - Body region to set splatter map data for
+	 * @param SplatterMapData - Splatter map data to set
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	void SetSplatterMapData(EBodyRegion BodyRegion, const FSplatterMapData& SplatterMapData);
+
+	/**
+	 * Clear all splatter maps
+	 */
+	UFUNCTION(BlueprintCallable, Category = "FLESH|Gore")
+	void ClearSplatterMaps();
+
+private:
+	// Splatter map data for each body region
+	UPROPERTY(EditAnywhere, Category = "FLESH|Gore", meta = (AllowPrivateAccess = "true"))
+	TMap<EBodyRegion, FSplatterMapData> SplatterMaps;
+
+	// Decal textures for different wound types
+	UPROPERTY(EditAnywhere, Category = "FLESH|Gore", meta = (AllowPrivateAccess = "true"))
+	TMap<FName, TObjectPtr<UTexture2D>> WoundDecals;
+
+	// Material for rendering to splatter maps
+	UPROPERTY(EditAnywhere, Category = "FLESH|Gore", meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<UMaterialInterface> SplatterRenderMaterial;
+
+	// Convert world location to UV coordinates on the character
+	FVector2D WorldLocationToUV(const FVector& Location, const FVector& Normal, EBodyRegion BodyRegion) const;
+
+	// Render decal to splatter map
+	void RenderToSplatterMap(UTexture2D* TargetTexture, UTexture2D* DecalTexture, const FVector2D& UV, 
+		float Size, float Rotation, const TMap<ESplatterMapChannel, float>& Channels);
+};

Source/FLESHEditor/FLESHEditor.Build.cs

@@ -11,6 +11,7 @@ public class FLESHEditor : ModuleRules
 		PublicIncludePaths.AddRange(
 			new string[] {
 				// ... add public include paths required here ...
+				"$(PluginDir)/Source/FLESHEditor/Public"
 			}
 			);
 				

Source/FLESHEditor/Private/DismembermentCompiler.cpp

@@ -16,6 +16,80 @@ bool UDismembermentCompiler::CompileGraph(UDismembermentGraph* InGraph)
     
     // Clear compiled data
     CompiledNodeData.Empty();
+    ExecutionOrder.Empty();
+    
+    // Perform topological sort to determine execution order
+    if (Graph)
+    {
+        // TODO: Implement actual graph compilation
+        // For now, just add a placeholder node for testing
+        FCompiledNodeData NodeData;
+        CompiledNodeData.Add(NodeData);
+        ExecutionOrder.Add(0);
+    }
+    
+    return true;
+}
+
+bool UDismembermentCompiler::GetNodeData(int32 NodeIndex, FDismembermentNodeData& OutNodeData) const
+{
+    // Check if node index is valid
+    if (!CompiledNodeData.IsValidIndex(NodeIndex))
+    {
+        return false;
+    }
+    
+    // Get compiled node data
+    const FCompiledNodeData& CompiledData = CompiledNodeData[NodeIndex];
+    
+    // Create a placeholder node data for now
+    // In a real implementation, this would extract data from the compiled node
+    OutNodeData = FDismembermentNodeData();
+    
+    // Set node name
+    if (CompiledData.Node)
+    {
+        OutNodeData.NodeName = CompiledData.Node->GetFName();
+    }
+    else
+    {
+        OutNodeData.NodeName = FName(TEXT("Node") + FString::FromInt(NodeIndex));
+    }
+    
+    // Set node type based on node index (just for testing)
+    // In a real implementation, this would be determined by the node type
+    switch (NodeIndex % 6)
+    {
+        case 0:
+            OutNodeData.NodeType = EDismembermentNodeType::Cut;
+            break;
+        case 1:
+            OutNodeData.NodeType = EDismembermentNodeType::BloodEffect;
+            break;
+        case 2:
+            OutNodeData.NodeType = EDismembermentNodeType::Physics;
+            break;
+        case 3:
+            OutNodeData.NodeType = EDismembermentNodeType::Organ;
+            break;
+        case 4:
+            OutNodeData.NodeType = EDismembermentNodeType::Wound;
+            break;
+        case 5:
+            OutNodeData.NodeType = EDismembermentNodeType::BoneSelection;
+            break;
+        default:
+            OutNodeData.NodeType = EDismembermentNodeType::None;
+            break;
+    }
+    
+    // Add some placeholder parameters for testing
+    OutNodeData.FloatParameters.Add(TEXT("Width"), 10.0f);
+    OutNodeData.FloatParameters.Add(TEXT("Depth"), 5.0f);
+    OutNodeData.VectorParameters.Add(TEXT("Location"), FVector(0.0f, 0.0f, 0.0f));
+    OutNodeData.VectorParameters.Add(TEXT("Direction"), FVector(0.0f, 0.0f, 1.0f));
+    OutNodeData.BoolParameters.Add(TEXT("CreateDecal"), true);
+    OutNodeData.BoolParameters.Add(TEXT("SimulatePhysics"), true);
     
     return true;
 }