diff --git a/docs/design/01-刀刃形成-各向异性流动设计.md b/docs/design/01-刀刃形成-各向异性流动设计.md
new file mode 100644
index 0000000..f39fca9
--- /dev/null
+++ b/docs/design/01-刀刃形成-各向异性流动设计.md
@@ -0,0 +1,1150 @@
+# 刀刃形成-各向异性流动设计
+
+**项目**: BladeSmith
+**文档类型**: 技术设计(专题)
+**版本**: 2.1
+**最后更新**: 2026-08-11
+**状态**: 整合自原 `2026-01-22-刀刃形成技术细节.md`,2026-08-11 增补参数语义/双区实现/流水线/连续性/同步/体积守恒/性能预算(P0+P1)
+
+> 本文档描述刀刃形成过程中各向异性材料流动、边缘约束与自适应网格细分的技术实现。需求见 [requirements/01-锤击形变与刀刃形成需求.md](../requirements/01-锤击形变与刀刃形成需求.md)。总体架构见 [00-锻造系统总体技术架构.md](00-锻造系统总体技术架构.md)。
+>
+> **范围声明**:
+> - **音效**(对应 requirements/01 §3.2 听觉反馈)**不在本文档范围**,由 WeaponComponent 与音频系统处理
+> - **斜向锤击**(HammerDir 非垂直场景)当前未覆盖,见 §7 已知限制
+> - **网格质量优化的算法细节**见 [design/03](./03-网格质量-增量式优化设计.md),本文档仅定义协作接口
+
+---
+
+## 1. 技术背景
+
+锻造刀刃时,材料需优先沿边缘方向流动而非均匀扩散,形成薄片状结构且保持边缘平整锐利。球形凸起机制无法满足方向性需求,需要各向异性材料流动算法。
+
+---
+
+## 2. 各向异性材料流动
+
+### 2.1 方向检测算法
+
+```cpp
+/**
+ * 查找最近的自由边界方向
+ * 材料会优先朝向自由边界流动(阻力最小)
+ */
+FVector FindNearestFreeEdgeDirection(
+    const FDynamicMesh3& Mesh,
+    const FVector& LocalPos,
+    const FVector& BoxHalfSize)
+{
+    // 计算到6个面的距离
+    float DistToEdges[6] = {
+        BoxHalfSize.X + LocalPos.X,  // -X面
+        BoxHalfSize.X - LocalPos.X,  // +X面
+        BoxHalfSize.Y + LocalPos.Y,  // -Y面
+        BoxHalfSize.Y - LocalPos.Y,  // +Y面
+        BoxHalfSize.Z + LocalPos.Z,  // -Z面
+        BoxHalfSize.Z - LocalPos.Z   // +Z面
+    };
+
+    // 找最近的边缘
+    int32 NearestEdge = 0;
+    float MinDist = DistToEdges[0];
+    for (int32 i = 1; i < 6; ++i)
+    {
+        if (DistToEdges[i] < MinDist)
+        {
+            MinDist = DistToEdges[i];
+            NearestEdge = i;
+        }
+    }
+
+    // 返回朝向最近边缘的方向
+    static const FVector EdgeDirections[6] = {
+        FVector(-1, 0, 0), FVector(1, 0, 0),
+        FVector(0, -1, 0), FVector(0, 1, 0),
+        FVector(0, 0, -1), FVector(0, 0, 1)
+    };
+
+    return EdgeDirections[NearestEdge];
+}
+
+/**
+ * 计算材料流动的主方向
+ * 主方向 = 朝向边缘 + 垂直于锤击方向
+ */
+FVector3f CalculatePrimaryFlowDirection(
+    const FVector& HammerDir,      // 锤击方向(通常是-Z)
+    const FVector& ToNearestEdge)  // 朝向最近边缘的方向
+{
+    // 移除锤击方向的分量(材料不能向锤头方向流动)
+    FVector3f PrimaryFlow = FVector3f(ToNearestEdge) -
+        FVector3f(HammerDir) * FVector::DotProduct(ToNearestEdge, HammerDir);
+
+    return PrimaryFlow.GetSafeNormal();
+}
+
+/**
+ * 计算次要流动方向(垂直于主方向和锤击方向)
+ */
+FVector3f CalculateSecondaryFlowDirection(
+    const FVector& HammerDir,
+    const FVector& PrimaryFlow)
+{
+    return FVector3f::CrossProduct(FVector3f(HammerDir), PrimaryFlow).GetSafeNormal();
+}
+```
+
+### 2.2 各向异性凸起计算
+
+```cpp
+/**
+ * 应用各向异性材料流动
+ * @param LocalHitPos 锤击位置(局部空间)
+ * @param ImpactRadius 锤击影响半径
+ * @param HammerDir 锤击方向
+ * @param AnisotropyRatio 各向异性比(主方向/次方向的流动强度比)
+ */
+void ApplyAnisotropicDeformation(
+    FDynamicMesh3& Mesh,
+    const FVector& LocalHitPos,
+    float ImpactRadius,
+    const FVector& HammerDir,
+    float AnisotropyRatio,  // 默认3.0,主方向流动强度是次方向的3倍
+    float BulgeStrength)
+{
+    // 计算流动方向
+    FVector ToNearestEdge = FindNearestFreeEdgeDirection(Mesh, LocalHitPos, BoxHalfSize);
+    FVector3f PrimaryFlow = CalculatePrimaryFlowDirection(HammerDir, ToNearestEdge);
+    FVector3f SecondaryFlow = CalculateSecondaryFlowDirection(HammerDir, PrimaryFlow);
+
+    // 对每个顶点应用形变
+    for (int32 VID : Mesh.VertexIndicesItr())
+    {
+        FVector VertexPos = Mesh.GetVertex(VID);
+        float Distance = FVector::Dist(VertexPos, LocalHitPos);
+
+        if (Distance < ImpactRadius)
+        {
+            // 将位置投影到流动方向
+            float DistAlongPrimary = FVector::DotProduct(
+                FVector(VertexPos - LocalHitPos), PrimaryFlow);
+            float DistAlongSecondary = FVector::DotProduct(
+                FVector(VertexPos - LocalHitPos), SecondaryFlow);
+
+            // 各向异性距离计算
+            // 主方向的"有效距离"更小(更容易到达)→ 凸起更大
+            float EffectiveDistance = FMath::Sqrt(
+                FMath::Square(DistAlongPrimary / AnisotropyRatio) +
+                FMath::Square(DistAlongSecondary)
+            );
+
+            float DistanceRatio = EffectiveDistance / ImpactRadius;
+
+            if (DistanceRatio < 1.0f)
+            {
+                // 使用FalloffExponent控制边缘过渡
+                float FalloffExponent = 2.0f;
+                float BulgeFactor = BulgeStrength *
+                    FMath::Pow(1.0f - DistanceRatio, FalloffExponent);
+
+                // 凸起方向 = 锤击方向(材料被挤压向外)
+                FVector Displacement = HammerDir * (-BulgeFactor);
+
+                // 应用形变
+                Mesh.SetVertex(VID, VertexPos + Displacement);
+            }
+        }
+    }
+}
+```
+
+### 2.3 参数说明
+
+| 参数 | 默认值 | 范围 | 效果 |
+|------|--------|------|------|
+| **AnisotropyRatio** | 3.0 | 1.0-10.0 | 主方向流动强度比。越大,边缘拉伸越明显 |
+| **BulgeStrength** | 0.5 | 0.1-2.0 | 凸起高度。需要配合ImpactRadius调整 |
+| **ImpactRadius** | 5.0 | 1.0-20.0 | 锤击影响半径(cm) |
+| **FalloffExponent** | 2.0 | 1.0-4.0 | 边缘过渡平滑度。越大,边界越锐利 |
+
+**技术调参指南**:
+- **均匀流动场景**: AnisotropyRatio = 1.0
+- **边缘锻造场景**: AnisotropyRatio = 3.0-5.0(明显方向性)
+- **精细整形场景**: AnisotropyRatio = 8.0-10.0(极端定向)
+
+### 2.4 参数语义统一
+
+各向异性形变涉及多个"力度/深度/强度"参数,需明确语义与调用契约,避免接口与实现脱节(本节回应 requirements/01 中"凸起高度强度"等多个参数的语义边界)。
+
+#### 2.4.1 参数定义与归属
+
+| 参数 | 单位 | 范围 | 语义 | 来源 |
+|---|---|---|---|---|
+| `ImpactForce` | 无 | 0.0-1.0 | 锤击力度归一化值,由 WeaponComponent 基于锤头速度计算 | 输入侧 |
+| `ImpactDepth` | cm | >0 | 100% 力度下的理论下压深度,由锤子配置决定 | 输入侧 |
+| `BulgeStrength` | 无 | 0.1-2.0 | 凸起区流动强度系数,相对下压深度的比例 | 本系统可调 |
+| `AnisotropyRatio` | 无 | 1.0-10.0 | 主方向流动强度比(各向异性程度) | 本系统可调 |
+| `BulgeRatio` | 无 | 0-2.0 | 凸起区半径相对 ImpactRadius 的扩展倍数(典型 0.8) | 本系统可调 |
+| `FalloffExponent` | 无 | 1.0-4.0 | 衰减曲线幂次,控制边界过渡锐利度 | 本系统可调 |
+
+#### 2.4.2 参数关系公式
+
+```
+ActualDepth = ImpactDepth × Clamp(ImpactForce, 0, 1)
+BulgeOuterRadius = ImpactRadius × (1 + BulgeRatio)
+```
+
+压缩区位移(顶点在 ImpactRadius 内):
+```
+VertexDeformation = ActualDepth × (1 - (Distance/ImpactRadius)^FalloffExponent)
+```
+
+凸起区位移高度(顶点在 ImpactRadius ~ BulgeOuterRadius 之间):
+```
+BulgeHeight = ActualDepth × BulgeStrength × BulgeFalloff
+其中 BulgeFalloff = 1 - (EffectiveDistance/(BulgeOuterRadius-ImpactRadius))^FalloffExponent
+```
+
+#### 2.4.3 调用契约
+
+`OnHammerImpact(HitLocation, HitNormal, ImpactRadius, ImpactDepth, ImpactForce)`:
+
+- 调用方(WeaponComponent)负责传入 `ImpactForce`(物理引擎计算)与 `ImpactDepth`(锤子配置)
+- 本函数内部必须使用 `ActualDepth = ImpactDepth × ImpactForce`,**不可**单独使用任一参数
+- `ImpactForce` 必须在 [0,1] 区间,函数内 `FMath::Clamp` 兜底
+- `HitNormal` 是世界空间的方向向量(非位置),必须用 `InverseTransformVector` 转入局部空间
+
+---
+
+### 2.5 体积守恒策略
+
+对应 [requirements/01 §1.2](../requirements/01-锤击形变与刀刃形成需求.md) 锻造过程可视化:材料从一处被挤压,应当在另一处凸起,体积不应凭空产生或消失。这是真实锻造的核心物理直觉。
+
+#### 2.5.1 当前实现的体积误差来源
+
+§3.4 的双区算法基于"Falloff 函数 + 经验系数",并非严格的体积守恒:
+
+| 来源 | 影响 |
+|---|---|
+| 压缩区下压体积 ∝ `ActualDepth × Falloff × Area` | 实际"挤压"的材料量 |
+| 凸起区隆起体积 ∝ `ActualDepth × BulgeStrength × BulgeFalloff × Area` | 实际"凸起"的材料量 |
+| 70/30 分量分配 | 凸起区 70% 向上 + 30% 向外,体积计算需考虑径向流失 |
+| `BulgeStrength` 默认 0.5 | 意味着凸起体积约为下压体积的 50%,剩余 50% 凭空消失 |
+
+**结论**: 当前实现是"近似体积守恒",实际体积误差可达 30-50%。在玩家可感知层面通常没问题,但对真实感敏感的玩家可能注意到"材料越打越少"。
+
+#### 2.5.2 守恒策略选项
+
+| 策略 | 描述 | 优点 | 缺点 |
+|---|---|---|---|
+| **A. 不守恒(当前默认)** | BulgeStrength 是独立可调参数 | 调参直观,性能无开销 | 体积误差大,违反直觉 |
+| **B. 软守恒**(推荐) | 计算下压体积,反解 BulgeStrength 使凸起体积 ≈ 下压体积 × 系数 | 物理直觉正确,BulgeStrength 仍有调参空间 | 每次锤击多一次积分计算 |
+| **C. 严格守恒** | 用拉格朗日乘子法约束 | 完全守恒 | 计算复杂,性能开销大 |
+
+#### 2.5.3 推荐:策略 B 软守恒
+
+**算法骨架**(伪代码):
+
+```cpp
+// 步骤 1: 计算压缩区下压体积(数值积分)
+float CompressedVolume = 0.0f;
+for (int32 VertexID : CompressedVertices)
+{
+    float Falloff = 1.0f - FMath::Pow(Distance/ImpactRadius, FalloffExponent);
+    CompressedVolume += ActualDepth * Falloff * GetVertexArea(VertexID);
+}
+
+// 步骤 2: 反解 BulgeStrength,使凸起体积 ≈ CompressedVolume × ConservationFactor
+// 凸起体积 ≈ BulgeStrength × Σ(BulgeFalloff_i × VertexArea_i) × 0.7(向上分量)
+// ⇒ BulgeStrength = CompressedVolume × ConservationFactor / (Σ × 0.7)
+float BulgeStrengthCorrected = CompressedVolume * ConservationFactor
+                              / (SumBulgeFalloffArea * 0.7f);
+
+// 步骤 3: 用校正后的 BulgeStrength 执行形变(同 §3.4)
+```
+
+**`ConservationFactor` 含义**:
+- `1.0` = 完全守恒(压缩体积 = 凸起体积)
+- `0.9` = 10% 体积损耗(模拟材料致密化/加工硬化导致的体积微小减少)
+- `0.5` ≈ 当前默认 BulgeStrength 行为(近似)
+
+**`GetVertexArea(VertexID)` 实现**: 取顶点邻接三角形面积的 1/3 之和,可在网格拓扑变化后增量更新,无需每次重算。
+
+#### 2.5.4 性能影响
+
+- 计算下压体积: O(N)(遍历压缩区顶点)
+- 反解 BulgeStrength: O(1)
+- 总额外开销: < 0.5ms(20 万顶点,仅压缩区遍历),可接受
+
+#### 2.5.5 调参建议
+
+| 场景 | ConservationFactor | 效果 |
+|---|---|---|
+| 真实模式 | 0.9 | 接近真实物理,体积基本守恒 |
+| 娱乐模式 | 0.5-0.7 | 凸起比真实少,玩家更容易控制形状 |
+| 夸张模式 | 1.1+ | 凸起比下压多,适合视觉冲击(非物理) |
+
+#### 2.5.6 与策略 A 的兼容
+
+策略 B 不破坏现有调参:
+- 当 `bEnableVolumeConservation = false`(默认): 走策略 A,直接使用配置的 `BulgeStrength`
+- 当 `bEnableVolumeConservation = true`: 走策略 B,`BulgeStrength` 配置值被忽略(或作为初始猜测)
+
+---
+
+## 3. 边缘平整约束
+
+### 3.1 边缘顶点标记
+
+```cpp
+/**
+ * 检测并标记边缘顶点
+ * 距离任何边界< EdgeThreshold 的顶点
+ */
+void MarkEdgeVertices(
+    FDynamicMesh3& Mesh,
+    TSet<int32>& OutEdgeVertices,
+    float EdgeThreshold = 0.5f)  // 5mm
+{
+    FVector BoxHalfSize = GetBoxHalfSize();
+
+    for (int32 VID : Mesh.VertexIndicesItr())
+    {
+        FVector Pos = Mesh.GetVertex(VID);
+
+        // 检查是否接近任何边界
+        bool bNearEdge = false;
+        bNearEdge |= FMath::Abs(Pos.X - BoxHalfSize.X) < EdgeThreshold;
+        bNearEdge |= FMath::Abs(Pos.X + BoxHalfSize.X) < EdgeThreshold;
+        bNearEdge |= FMath::Abs(Pos.Y - BoxHalfSize.Y) < EdgeThreshold;
+        bNearEdge |= FMath::Abs(Pos.Y + BoxHalfSize.Y) < EdgeThreshold;
+        bNearEdge |= FMath::Abs(Pos.Z - BoxHalfSize.Z) < EdgeThreshold;
+        bNearEdge |= FMath::Abs(Pos.Z + BoxHalfSize.Z) < EdgeThreshold;
+
+        if (bNearEdge)
+        {
+            OutEdgeVertices.Add(VID);
+        }
+    }
+}
+```
+
+### 3.2 线性约束应用
+
+```cpp
+/**
+ * 对边缘顶点应用线性约束
+ * 形变后将边缘顶点投影到拟合直线上,保持平整
+ */
+void ApplyEdgeLinearConstraint(
+    FDynamicMesh3& Mesh,
+    const TSet<int32>& EdgeVertices)
+{
+    for (int32 VID : EdgeVertices)
+    {
+        if (!Mesh.IsVertex(VID))
+            continue;
+
+        // 找到此顶点的边缘邻居
+        TArray<int32> EdgeNeighbors;
+        for (int32 NbrVID : Mesh.VtxVerticesItr(VID))
+        {
+            if (EdgeVertices.Contains(NbrVID))
+            {
+                EdgeNeighbors.Add(NbrVID);
+            }
+        }
+
+        if (EdgeNeighbors.Num() >= 2)
+        {
+            // 使用主成分分析(PCA)拟合直线
+            FVector CurrentPos = Mesh.GetVertex(VID);
+            FVector LineOrigin, LineDirection;
+
+            FitLineToPoints(Mesh, EdgeNeighbors, LineOrigin, LineDirection);
+
+            // 投影到拟合线上
+            FVector ProjectedPos = ProjectPointToLine(CurrentPos, LineOrigin, LineDirection);
+
+            // 稍微平滑更新(避免突变)
+            FVector SmoothPos = FMath::Lerp(CurrentPos, ProjectedPos, 0.5f);
+
+            Mesh.SetVertex(VID, SmoothPos);
+        }
+    }
+}
+```
+
+### 3.3 PCA直线拟合
+
+```cpp
+/**
+ * 使用PCA拟合直线到点集
+ */
+void FitLineToPoints(
+    const FDynamicMesh3& Mesh,
+    const TArray<int32>& VertexIDs,
+    FVector& OutOrigin,
+    FVector& OutDirection)
+{
+    // 计算质心
+    FVector Centroid = FVector::ZeroVector;
+    for (int32 VID : VertexIDs)
+    {
+        Centroid += Mesh.GetVertex(VID);
+    }
+    Centroid /= VertexIDs.Num();
+
+    // 计算协方差矩阵
+    float CovXX = 0, CovYY = 0, CovZZ = 0;
+    float CovXY = 0, CovXZ = 0, CovYZ = 0;
+
+    for (int32 VID : VertexIDs)
+    {
+        FVector P = Mesh.GetVertex(VID) - Centroid;
+        CovXX += P.X * P.X;
+        CovYY += P.Y * P.Y;
+        CovZZ += P.Z * P.Z;
+        CovXY += P.X * P.Y;
+        CovXZ += P.X * P.Z;
+        CovYZ += P.Y * P.Z;
+    }
+
+    // 构建协方差矩阵
+    FMatrix33 CovMatrix(
+        FVector3f(CovXX, CovXY, CovXZ),
+        FVector3f(CovXY, CovYY, CovYZ),
+        FVector3f(CovXZ, CovYZ, CovZZ)
+    );
+
+    // 计算特征向量(主方向 = 最大特征值对应的向量)
+    FVector3f EigenValues;
+    FMatrix33 EigenVectors;
+    FMatrix33::EigenDecomposition(CovMatrix, EigenValues, EigenVectors);
+
+    // 最大特征值对应的列向量是主方向
+    OutOrigin = Centroid;
+    OutDirection = FVector(EigenVectors.GetColumn(0));  // 第一主成分
+}
+
+/**
+ * 将点投影到直线上
+ */
+FVector ProjectPointToLine(
+    const FVector& Point,
+    const FVector& LineOrigin,
+    const FVector& LineDirection)
+{
+    FVector ToPoint = Point - LineOrigin;
+    float ProjectionLength = FVector::DotProduct(ToPoint, LineDirection);
+    return LineOrigin + LineDirection * ProjectionLength;
+}
+```
+
+### 3.4 形变核心实现
+
+本系统的形变核心函数。实现要点(基于 impl 实际代码回填):
+- **双区算法**: 压缩区(ImpactRadius 内)沿锤击法线下压;凸起区(ImpactRadius~BulgeOuterRadius)材料 70% 向上 + 30% 向外流动
+- **各向异性凸起**: 凸起区使用 §2.2 的 EffectiveDistance 公式,主方向凸起更大
+- **累积应变**: 每顶点位移量累加到 `AccumulatedStrain`,供 design/04 硬化模型消费
+- **(可选)边缘约束 + 自适应细分** 在同一 EditMesh 内执行,避免多次 lock
+
+> 本函数仅负责"形变核心"。完整的锤击事件流水线(含 design/03 网格优化、design/04-07 物理更新)见 §3.5。
+
+```cpp
+void ADynamicIronBlock::OnHammerImpact(
+    FVector HitLocation,
+    FVector HitNormal,
+    float ImpactRadius,
+    float ImpactDepth,
+    float ImpactForce)
+{
+    // 获取组件与网格
+    UDynamicMeshComponent* DynMeshComp = GetDynamicMeshComponent();
+    if (!DynMeshComp)
+    {
+        UE_LOG(LogTemp, Error, TEXT("DynamicIronBlock: DynamicMeshComponent is null"));
+        return;
+    }
+    UDynamicMesh* DynMesh = DynMeshComp->GetDynamicMesh();
+    if (!DynMesh)
+    {
+        UE_LOG(LogTemp, Error, TEXT("DynamicIronBlock: DynamicMesh is null"));
+        return;
+    }
+
+    // 力度归一化(参考 §2.4.3 调用契约)
+    ImpactForce = FMath::Clamp(ImpactForce, 0.0f, 1.0f);
+
+    // 世界→局部(注意:HitNormal 是方向向量,必须用 InverseTransformVector,不能用 InverseTransformPosition)
+    FTransform ActorTransform = GetActorTransform();
+    FVector LocalHitLocation = ActorTransform.InverseTransformPosition(HitLocation);
+    FVector LocalHitNormal = ActorTransform.InverseTransformVector(HitNormal).GetSafeNormal();
+
+    // 实际下压深度(参考 §2.4.2)
+    float ActualDepth = ImpactDepth * ImpactForce;
+
+    // 计算材料流动方向
+    FVector BoxHalfSize = BoxSize * 0.5f;
+    FVector ToNearestEdge = FindNearestFreeEdgeDirection(LocalHitLocation, BoxHalfSize);
+    FVector PrimaryFlow = CalculatePrimaryFlowDirection(LocalHitNormal, ToNearestEdge);
+    FVector SecondaryFlow = CalculateSecondaryFlowDirection(LocalHitNormal, PrimaryFlow);
+
+    float BulgeOuterRadius = ImpactRadius * (1.0f + BulgeRatio);
+
+    DynMesh->EditMesh([&](FDynamicMesh3& EditMesh)
+    {
+        // ===== 1. 双区形变 =====
+        for (int32 VertexID : EditMesh.VertexIndicesItr())
+        {
+            FVector3d VertexPos = EditMesh.GetVertex(VertexID);
+            FVector VertexPosFloat(VertexPos.X, VertexPos.Y, VertexPos.Z);
+            float Distance = FVector::Dist(VertexPosFloat, LocalHitLocation);
+
+            if (Distance >= BulgeOuterRadius)
+                continue;
+
+            FVector Displacement = FVector::ZeroVector;
+
+            // 1a. 压缩区:ImpactRadius 内,沿锤击法线下压
+            if (Distance < ImpactRadius)
+            {
+                float NormalizedDist = Distance / ImpactRadius;
+                float Falloff = 1.0f - FMath::Pow(NormalizedDist, FalloffExponent);
+                float VertexDeformation = ActualDepth * Falloff;
+                Displacement = -LocalHitNormal * VertexDeformation;
+            }
+            // 1b. 凸起区:ImpactRadius ~ BulgeOuterRadius,材料向上+向外流动
+            else
+            {
+                float DistAlongPrimary = FVector::DotProduct(
+                    FVector(VertexPosFloat - LocalHitLocation), PrimaryFlow);
+                float DistAlongSecondary = FVector::DotProduct(
+                    FVector(VertexPosFloat - LocalHitLocation), SecondaryFlow);
+
+                // 各向异性距离(主方向"更近" → 凸起更大)
+                float EffectiveDistance = FMath::Sqrt(
+                    FMath::Square(DistAlongPrimary / AnisotropyRatio) +
+                    FMath::Square(DistAlongSecondary)
+                );
+                float DistanceInBulgeZone = EffectiveDistance / (BulgeOuterRadius - ImpactRadius);
+
+                if (DistanceInBulgeZone < 1.0f)
+                {
+                    float BulgeFalloff = 1.0f - FMath::Pow(DistanceInBulgeZone, FalloffExponent);
+                    float BulgeHeight = ActualDepth * BulgeStrength * BulgeFalloff;
+
+                    // 70% 向上(反法线方向)+ 30% 向外(径向,各向异性)
+                    FVector UpwardDisplacement = -LocalHitNormal * BulgeHeight * 0.7f;
+
+                    FVector RadialDir = PrimaryFlow * DistAlongPrimary + SecondaryFlow * DistAlongSecondary;
+                    RadialDir.Normalize();
+                    FVector OutwardDisplacement = RadialDir * BulgeHeight * 0.3f;
+
+                    Displacement = UpwardDisplacement + OutwardDisplacement;
+                }
+            }
+
+            // 应用形变 + 累积应变(供 design/04 硬化模型消费)
+            if (!Displacement.IsNearlyZero())
+            {
+                EditMesh.SetVertex(VertexID, VertexPos + FVector3d(Displacement.X, Displacement.Y, Displacement.Z));
+
+                if (AccumulatedStrain.IsValid())
+                {
+                    float CurrentStrain = AccumulatedStrain->GetValue(VertexID);
+                    AccumulatedStrain->SetValue(VertexID, CurrentStrain + Displacement.Size());
+                }
+            }
+        }
+
+        // ===== 2. (可选)边缘平整约束 =====
+        // 仅处理受影响区域的边缘顶点,避免全网格遍历
+        if (bEnableEdgeConstraint)
+        {
+            TSet<int32> EdgeVertices;
+            MarkEdgeVertices(EditMesh, EdgeVertices, EdgeThreshold);
+
+            TSet<int32> AffectedEdges;
+            for (int32 VID : EdgeVertices)
+            {
+                if (!EditMesh.IsVertex(VID)) continue;
+                FVector3d Pos = EditMesh.GetVertex(VID);
+                FVector PosFloat(Pos.X, Pos.Y, Pos.Z);
+                if (FVector::Dist(PosFloat, LocalHitLocation) < ImpactRadius * 1.5f)
+                {
+                    AffectedEdges.Add(VID);
+                }
+            }
+
+            if (AffectedEdges.Num() > 0)
+            {
+                ApplyEdgeLinearConstraint(EditMesh, AffectedEdges);
+            }
+        }
+
+        // ===== 3. (可选,降频)自适应细分 =====
+        // 详见 §4。每 5 次锤击执行一次,避免过度细分
+        if (bEnableAdaptiveRefinement && (HammerHitCount % 5 == 0))
+        {
+            SubdivideHighCurvatureEdges(EditMesh, 0.5f, 2.0f, 100);
+        }
+    }, EDynamicMeshChangeType::GeneralEdit, EDynamicMeshAttributeChangeFlags::Unknown, false);
+
+    // ===== 4-6. 法线重算 / 渲染同步 / BVH 重建(详见 §3.7)=====
+    FGeometryScriptCalculateNormalsOptions NormalOp;
+    UGeometryScriptLibrary_MeshNormalsFunctions::RecomputeNormals(DynMesh, NormalOp);
+    DynMeshComp->NotifyMeshUpdated();
+    GenerateBVH();
+
+    HammerHitCount++;
+}
+```
+
+---
+
+### 3.5 锤击事件完整流水线
+
+§3.4 描述了"形变核心"。在实际锤击事件中,形变核心只是完整流水线的第一步。本节定义跨子系统的协作顺序、数据流与调度职责,作为实现的权威参考。
+
+> **替代关系**: 本节细化了 [design/00 §3](./00-锻造系统总体技术架构.md) 的 8 步物理流水线在几何处理层面的细节,也补充了 [design/03 §8.1](../design/03-网格质量-增量式优化设计.md) 的简化集成示例。当本节与 design/03 §8.1 冲突时,以本节为准。
+
+#### 3.5.1 完整流水线
+
+一次完整的 `OnHammerImpact` 调用,内部按以下顺序执行(标 ★ 的步骤是 design/01 的职责):
+
+```
+[输入] HitLocation, HitNormal, ImpactRadius, ImpactDepth, ImpactForce
+  │
+  ▼
+0. 输入预处理
+   - ImpactForce Clamp 到 [0,1]
+   - 世界→局部坐标转换(参考 §3.4)
+   - ActualDepth = ImpactDepth × ImpactForce
+                 │
+                 ▼
+1. ★ EditMesh 开始(单次 lock)
+   1a. ★ 压缩区 + 凸起区双区形变(§3.4)
+   1b. ★ AccumulatedStrain 累积(供 design/04 消费)
+   1c. ★ PolishAmount 更新(供 design/02 消费)
+   1d. ★ (可选)边缘平整约束(§3)
+   1e. ★ (可选,降频)自适应细分(§4)
+                 │
+                 ▼
+2. 网格质量优化(design/03)
+   2a. FindAffectedTriangles
+   2b. 边翻转(FlipEdgesToImproveQuality)
+   2c. Laplacian 平滑(SmoothVertices)
+   2d. (降频)FRemesher 重网格(RemeshRegion)
+   ─ 可在 EditMesh 内执行,也可独立 lock
+                 │
+                 ▼
+3. EditMesh 提交
+                 │
+                 ▼
+4. 材料状态更新(对应 design/00 §3 物理流水线)
+   4a. 硬化计算(design/04,基于 AccumulatedStrain)
+   4b. 应力累积(design/06)
+   4c. 温度采样→塑性系数(架构层)
+   4d. 疲劳累积(design/07)
+   4e. 裂纹判定与扩展(design/06/07)
+                 │
+                 ▼
+5. 视觉与材质更新
+   5a. 法线重算(RecomputeNormals)
+   5b. 顶点颜色更新(温度/打磨度/相态,design/02/05)
+   5c. 动态材质参数更新(回火色/氧化层,design/05)
+                 │
+                 ▼
+6. 碰撞与渲染同步(§3.7)
+   6a. BVH 重建(GenerateBVH)
+   6b. NotifyMeshUpdated / MarkRenderStateDirty
+                 │
+                 ▼
+7. ★ HammerHitCount++(供下次锤击的降频判断)
+```
+
+#### 3.5.2 跨子系统数据契约
+
+design/01 产生以下数据,被其他子系统消费:
+
+| 产出 | 类型 | 消费者 | 用途 |
+|---|---|---|---|
+| `AccumulatedStrain` 累积 | 顶点属性增量 | design/04 硬化、design/06 应力、design/07 疲劳 | 输入 |
+| `PolishAmount` 更新 | 顶点属性增量 | design/02 表面磨损 | 输入(打磨度增加) |
+| 受影响顶点集合 | `TSet<int32>` | design/03 网格优化 | 局部化处理范围 |
+| 形变后的网格拓扑 | `FDynamicMesh3` | design/03、design/06 裂纹检测 | 几何基础 |
+
+#### 3.5.3 与 design/03 网格优化的协作
+
+**职责划分**:
+- design/01 负责"产生形变"——决定网格顶点位置如何变化
+- design/03 负责"修复退化"——决定网格拓扑如何调整以维持质量
+
+**调用方式**(两种方案,项目集成时确定):
+
+| 方案 | 描述 | 优点 | 缺点 | 适用 |
+|---|---|---|---|---|
+| **A. 同 EditMesh 内串行** | design/01 在 EditMesh 内直接调用 design/03 的函数 | 单次 lock,开销最小 | 子系统耦合 | 简化集成 |
+| **B. 上层调度器解耦**(推荐) | design/01 完成形变后,由上层调度器调用 design/03 | 子系统解耦,职责清晰 | 两次 EditMesh lock,轻微开销 | 长期可维护 |
+
+**关键要求**(无论哪种方案):design/01 必须输出"受影响三角形集合"供 design/03 局部化处理。当前 §3.4 实现里只跟踪了"边缘顶点",需扩展为完整的"受影响三角形"集合(参考 design/03 §8.2 `FindAffectedTriangles`)。
+
+#### 3.5.4 与 design/00 物理流水线的对应
+
+[design/00 §3](./00-锻造系统总体技术架构.md) 定义了 8 步物理流水线。本节是其几何层面的扩展:
+
+| design/00 §3 步骤 | 本节对应步骤 | 备注 |
+|---|---|---|
+| 1. 形变计算 | §3.5.1 步骤 1 | design/01 核心 |
+| 2. 更新顶点应变累积 | §3.5.1 步骤 1b | 在 EditMesh 内 |
+| 3. 从温度体素采样 | §3.5.1 步骤 4c | 架构层 |
+| 4. 硬化计算 | §3.5.1 步骤 4a | design/04 |
+| 5. 应力累积 | §3.5.1 步骤 4b | design/06 |
+| 6. 体素应变率/淬火 | §3.5.1 步骤 4(异步 GPU) | design/05 |
+| 7. 疲劳与裂纹 | §3.5.1 步骤 4d/4e | design/07 |
+| 8. 材质可视化 | §3.5.1 步骤 5 | design/02/05 |
+
+**design/00 §3 未覆盖的两个关键步骤**(由本节补充):
+- **步骤 2**: 网格质量优化(几何层面)
+- **步骤 6**: 碰撞与渲染同步(基础设施层面)
+
+---
+
+### 3.6 形变连续性保证
+
+对应 [requirements/01 §1.4](../requirements/01-锤击形变与刀刃形成需求.md)"形变连续性":连续锻打能逐步把铁块变形成目标形状,每次锤击的形变应当是连续的、可预测的,不会出现突变或奇怪形状。
+
+#### 3.6.1 单次锤击的平滑过渡
+
+形变函数通过以下机制保证单次锤击内部的平滑性:
+
+- **FalloffExponent 衰减**: 压缩区与凸起区都使用 `(1 - ratio)^FalloffExponent` 衰减,边界处位移趋近 0,中心最大,确保空间连续
+- **双区衔接**: 压缩区(ImpactRadius 内)与凸起区(ImpactRadius~BulgeOuterRadius)在 ImpactRadius 边界处位移都趋近于 0,避免突变
+- **径向归一化**: 凸起区 `RadialDir.Normalize()` 确保方向连续
+
+**禁止做法**: 在 EditMesh 内对顶点位置做硬切换(如 `if (cond) SetVertex(A) else SetVertex(B)`),会破坏空间连续性。
+
+#### 3.6.2 多次锤击的累积
+
+- **AccumulatedStrain 单调累加**: 每次锤击的位移量累加,不会归零,玩家能感知"金属越打越变形"
+- **HardnessCoefficient 反馈**(由 design/04 实现): 累积应变越高,下次形变阻力越大(参考 [design/04](./04-物理模拟-加工硬化与晶粒演化设计.md) 加工硬化)
+- **PolishAmount 单调上升**: 打磨度只增不减,表面从生锈到光亮的过渡是单调的
+
+#### 3.6.3 时间稳定性(避免震荡)
+
+- **无状态依赖**: 形变函数不依赖前一帧状态,只依赖当前网格与锤击参数。同一位置多次锤击,效果是单调累积而非震荡
+- **边缘约束的阻尼**: §3.2 `ApplyEdgeLinearConstraint` 中 `FMath::Lerp(CurrentPos, ProjectedPos, 0.5f)` 用 50% 插值避免突变。若用 100% 投影会导致边缘顶点在多次锤击后跳变
+
+#### 3.6.4 累积退化交接给 design/03
+
+多次锤击后网格质量会下降(细长三角形、面积过小等)。design/01 不直接处理退化,而是通过两个机制交接:
+
+| 退化类型 | 检测/触发 | 处理者 |
+|---|---|---|
+| 大三角形 / 高曲率边 | §4 `SubdivideHighCurvatureEdges`(曲率 > 30° / 边长 > 2cm) | design/01 §4 自适应细分 |
+| 细长三角形(长宽比 > 10:1) | design/03 `IsDegenerateTriangle` | design/03 边翻转 + 重网格 |
+| 顶点分布不均 | design/03 `CalculateVertexCurvature` | design/03 Laplacian 平滑 |
+
+具体阈值与算法见 [design/03](./03-网格质量-增量式优化设计.md)。
+
+---
+
+### 3.7 碰撞与渲染同步
+
+对应 [requirements/03 §5](../requirements/03-网格质量与性能需求.md)"碰撞检测稳定,不会出现打空或检测错误"与"网格优化过程透明,不影响形变视觉效果"。
+
+#### 3.7.1 BVH 重建
+
+锤击形变改变了网格顶点位置,碰撞检测加速结构必须同步更新,否则下一次锤击会"打空"或检测到错误位置。
+
+**当前实现**(§3.4 末尾):
+
+```cpp
+GenerateBVH();  // 全量重建
+```
+
+**性能特征**:
+- 全量重建: 5-10ms(20 万顶点),已在 §5 性能预算内
+- 增量重建(未来改进): 仅更新受影响区域的 BVH 节点,可降至 <2ms
+
+**禁止**: 在 EditMesh 内调用 GenerateBVH(此时网格还未提交)。必须在 EditMesh 退出后调用。
+
+#### 3.7.2 法线重算
+
+形变改变了网格几何,法线必须重算,否则:
+- 着色错误(表面出现条纹/暗斑)
+- design/02 表面磨损的 `WorldNormal` 输入错误
+
+```cpp
+FGeometryScriptCalculateNormalsOptions NormalOp;
+UGeometryScriptLibrary_MeshNormalsFunctions::RecomputeNormals(DynMesh, NormalOp);
+```
+
+**频率**: 每次锤击后必须执行。**无法降频**——法线错误肉眼立即可见。
+
+#### 3.7.3 渲染状态通知
+
+DynamicMesh 的渲染数据有内部缓存,形变后必须显式失效:
+
+```cpp
+DynMeshComp->NotifyMeshUpdated();              // 通知组件网格已更新
+DynMeshComp->MarkRenderStateDirty();           // 标记渲染状态脏(强制重建渲染数据)
+DynMeshComp->MarkRenderDynamicDataDirty();     // 标记动态数据脏(顶点颜色等)
+```
+
+**调用时机**: EditMesh 退出之后,法线重算之后,BVH 重建之后。
+
+#### 3.7.4 异步可能性
+
+某些步骤可以延后到帧尾执行,不阻塞锤击响应:
+
+| 步骤 | 可否异步 | 说明 |
+|---|---|---|
+| 法线重算 | ❌ 否 | 视觉延迟肉眼可见 |
+| 渲染状态通知 | ❌ 否 | 必须当帧完成 |
+| BVH 重建 | ✅ 是 | 下一次锤击前完成即可 |
+
+**BVH 异步期间的冲突处理**: 若玩家在 BVH 重建期间再次锤击,需要等待 BVH 完成或使用旧 BVH(可能"打空")。这是性能与响应性的权衡,默认选择"等待"(保证碰撞正确)。
+
+---
+
+## 4. 自适应网格细分
+
+### 4.1 高曲率边缘细分
+
+```cpp
+/**
+ * 检测高曲率边缘并细分
+ */
+void SubdivideHighCurvatureEdges(
+    FDynamicMesh3& Mesh,
+    float CurvatureThreshold,    // 曲率阈值
+    float MaxEdgeLength,         // 最大边长
+    int32 MaxSubdivisions)       // 最大细分次数
+{
+    int32 SubdivisionCount = 0;
+
+    for (int32 EID : Mesh.EdgeIndicesItr())
+    {
+        if (SubdivisionCount >= MaxSubdivisions)
+            break;
+
+        // 跳过边界边
+        if (Mesh.IsBoundaryEdge(EID))
+            continue;
+
+        FIndex2i EdgeVerts = Mesh.GetEdgeV(EID);
+        FVector V0 = Mesh.GetVertex(EdgeVerts.A);
+        FVector V1 = Mesh.GetVertex(EdgeVerts.B);
+        float EdgeLength = FVector::Dist(V0, V1);
+
+        // 边太长或曲率过高 → 细分
+        float EdgeCurvature = CalculateEdgeCurvature(Mesh, EID);
+
+        if (EdgeLength > MaxEdgeLength && EdgeCurvature > CurvatureThreshold)
+        {
+            // 细分此边
+            FDynamicMesh3::FEdgeSplitInfo SplitInfo;
+            EMeshResult Result = Mesh.SplitEdge(EID, SplitInfo);
+
+            if (Result == EMeshResult::Ok)
+            {
+                // 新顶点位置 = 中点
+                FVector MidPoint = (V0 + V1) * 0.5f;
+                Mesh.SetVertex(SplitInfo.NewVertex, MidPoint);
+
+                // 插值顶点属性
+                InterpolateVertexAttributes(Mesh, EdgeVerts.A, EdgeVerts.B, SplitInfo.NewVertex);
+
+                SubdivisionCount++;
+            }
+        }
+    }
+}
+```
+
+### 4.2 曲率计算
+
+```cpp
+/**
+ * 计算边的曲率(基于邻面法线夹角)
+ */
+float CalculateEdgeCurvature(const FDynamicMesh3& Mesh, int32 EdgeID)
+{
+    FIndex2i EdgeTris = Mesh.GetEdgeT(EdgeID);
+
+    // 边界边曲率为0
+    if (EdgeTris.B == IndexConstants::InvalidID)
+        return 0.0f;
+
+    // 获取两个三角形的法线
+    FVector Normal0 = Mesh.GetTriNormal(EdgeTris.A);
+    FVector Normal1 = Mesh.GetTriNormal(EdgeTris.B);
+
+    // 法线夹角 = 曲率度量
+    float Dot = FVector::DotProduct(Normal0, Normal1);
+    return FMath::Acos(Dot);  // 返回弧度
+}
+```
+
+### 4.3 属性插值
+
+```cpp
+/**
+ * 插值顶点属性
+ * 确保新顶点继承正确的材料状态
+ */
+void InterpolateVertexAttributes(
+    FDynamicMesh3& Mesh,
+    int32 VID0,
+    int32 VID1,
+    int32 NewVID)
+{
+    // 位置(已由SplitEdge处理)
+
+    // 初始位置
+    FVector InitPos0 = InitialPositions->GetValue(VID0);
+    FVector InitPos1 = InitialPositions->GetValue(VID1);
+    InitialPositions->SetValue(NewVID, (InitPos0 + InitPos1) * 0.5f);
+
+    // 打磨度
+    float Polish0 = PolishAmount->GetValue(VID0);
+    float Polish1 = PolishAmount->GetValue(VID1);
+    PolishAmount->SetValue(NewVID, (Polish0 + Polish1) * 0.5f);
+
+    // 累积应变
+    float Strain0 = AccumulatedStrain->GetValue(VID0);
+    float Strain1 = AccumulatedStrain->GetValue(VID1);
+    AccumulatedStrain->SetValue(NewVID, (Strain0 + Strain1) * 0.5f);
+
+    // 硬度
+    float Hardness0 = HardnessCoefficient->GetValue(VID0);
+    float Hardness1 = HardnessCoefficient->GetValue(VID1);
+    HardnessCoefficient->SetValue(NewVID, (Hardness0 + Hardness1) * 0.5f);
+
+    // 晶粒尺寸
+    float Grain0 = GrainSize->GetValue(VID0);
+    float Grain1 = GrainSize->GetValue(VID1);
+    GrainSize->SetValue(NewVID, (Grain0 + Grain1) * 0.5f);
+
+    // 顶点颜色
+    FColor Color0 = Mesh.GetVertexColor(VID0);
+    FColor Color1 = Mesh.GetVertexColor(VID1);
+    FLinearColor LinearColor0(Color0);
+    FLinearColor LinearColor1(Color1);
+    FLinearColor AvgColor = (LinearColor0 + LinearColor1) * 0.5f;
+    Mesh.SetVertexColor(NewVID, AvgColor.ToFColor());
+}
+```
+
+### 4.4 集成到锤击流程
+
+```cpp
+void ADynamicIronBlock::OnHammerImpact(...)
+{
+    // ... 形变计算 ...
+
+    // 自适应细分(每隔几次锤击执行,避免过度细分)
+    if (bEnableAdaptiveRefinement && HammerHitCount % 5 == 0)
+    {
+        SubdivideHighCurvatureEdges(
+            *DynamicMesh,
+            CurvatureThreshold = 0.5f,  // ~30度角
+            MaxEdgeLength = 2.0f,        // 2cm
+            MaxSubdivisions = 100
+        );
+    }
+}
+```
+
+---
+
+## 5. 性能考虑
+
+### 5.1 计算复杂度
+
+| 操作 | 复杂度 | 实际耗时(20万顶点) |
+|------|--------|---------------------|
+| 各向异性凸起 | O(N) | 2-3ms |
+| 边缘约束(PCA) | O(N×K) | +3-5ms |
+| 自适应细分 | O(E) | +2-4ms |
+| 属性插值 | O(1) per顶点 | 可忽略 |
+
+### 5.2 优化建议
+
+1. **限制约束区域**: 只对受影响的边缘顶点应用约束
+2. **降低细分频率**: 每5-10次锤击才细分一次
+3. **LOD策略**: 远距离铁块使用简化约束
+4. **异步计算**: 细分可以延后到帧尾执行
+
+---
+
+### 5.3 性能预算协调策略
+
+对应 [requirements/03 §5](../requirements/03-网格质量与性能需求.md) 验收点"单次锤击总耗时(形变+优化)≤ 7ms"。
+
+§5.1 复杂度表的最坏情况合计 7-12ms,需通过协调策略确保实测落在 7ms 内。
+
+#### 5.3.1 实测耗时 vs 最坏情况
+
+§5.1 的复杂度表是"全网格遍历"的最坏情况。实际通过增量式处理,耗时大幅下降:
+
+| 操作 | 最坏情况 | 增量式实测 | 降幅 |
+|---|---|---|---|
+| 各向异性凸起 | 2-3ms (20万顶点全遍历) | 0.5-1ms(仅 BulgeOuterRadius 内,约 5-10% 顶点) | -70% |
+| PCA 边缘约束 | 3-5ms(全网格边缘) | 0.5-1.5ms(仅 AffectedEdges,约 1-5% 边缘顶点) | -70% |
+| 自适应细分 | 2-4ms(每次都做) | 0.4-0.8ms(5 次锤击做一次,均摊) | -80% |
+| **合计** | **7-12ms** | **1.4-3.3ms** | **-75%** |
+
+**结论**: 增量式处理后,design/01 自身开销约 1.4-3.3ms,留出 3.7-5.6ms 给 design/03 网格优化与其他子系统。
+
+#### 5.3.2 锤击事件 7ms 预算分配
+
+按 §3.5 流水线分配预算:
+
+| 步骤 | 子系统 | 预算 | 备注 |
+|---|---|---|---|
+| 1a-1c 双区形变 + 应变累积 | design/01 | 1ms | O(N) 增量 |
+| 1d 边缘约束(可选) | design/01 | 1ms | 仅 AffectedEdges |
+| 1e 自适应细分(降频) | design/01 | 0.5ms | 5 次均摊 |
+| 2 网格质量优化 | design/03 | 1-2ms | 边翻转/平滑/重网格 |
+| 4 材料状态更新 | design/04/06/07 | 0.5ms | 公式应用 |
+| 5a 法线重算 | 渲染层 | 0.5ms | 全网格 |
+| 5b 顶点颜色更新 | design/02/05 | 0.3ms | 全网格 |
+| 6a BVH 重建 | 碰撞层 | 0.5-1ms | 全量(增量改进见 §3.7.1) |
+| 6b 渲染同步 | 渲染层 | 0.1ms | NotifyMeshUpdated |
+| **合计** | | **5-7ms** | 在预算内 |
+
+#### 5.3.3 超预算时的降级策略
+
+当实测超 7ms 时,按以下优先级降级(优先保证玩家可感知的体验):
+
+| 优先级 | 降级项 | 影响 |
+|---|---|---|
+| 1(最先降) | 关闭自适应细分(`bEnableAdaptiveRefinement = false`) | 刀刃细节略差,形变仍正常 |
+| 2 | 降低 design/03 重网格频率(RemeshCounter 周期 5 → 10) | 网格质量略降,视觉无明显差异 |
+| 3 | 关闭边缘约束(`bEnableEdgeConstraint = false`) | 边缘略波纹,形变仍正常 |
+| 4(最后降) | 减小 ImpactRadius | 影响玩家直觉,谨慎使用 |
+
+**禁止降级**: 双区形变核心、法线重算、BVH 重建——这些是正确性保证。
+
+#### 5.3.4 帧率自适应联动
+
+参考 [requirements/03 §2 自动调参](../requirements/03-网格质量与性能需求.md):
+
+```cpp
+// 在 Tick 中检查帧率,动态调整优化强度
+void ADynamicIronBlock::AutoAdjustOptimizationSettings()
+{
+    float CurrentFPS = 1.0f / GetWorld()->GetDeltaSeconds();
+
+    if (CurrentFPS < 30.0f)
+    {
+        // 帧率低:降级
+        bEnableAdaptiveRefinement = false;
+        bEnableEdgeConstraint = false;
+        RemeshCounterPeriod = 10;  // design/03 重网格频率
+    }
+    else if (CurrentFPS > 55.0f)
+    {
+        // 帧率高:恢复
+        bEnableAdaptiveRefinement = true;
+        bEnableEdgeConstraint = bUserEnabledEdgeConstraint;
+        RemeshCounterPeriod = 5;
+    }
+}
+```
+
+#### 5.3.5 与 design/03 的预算共享
+
+design/01 与 design/03 共享"网格处理"预算(约 2.5-3.5ms 合计)。两者通过以下机制协调:
+
+- **共享受影响区域**: design/01 输出 `AffectedTriangles`,design/03 直接使用,避免重复查找
+- **共享 EditMesh lock**: 若选 §3.5.3 方案 A,两者在同一 EditMesh 内执行,避免多次解锁开销
+- **降频同步**: 当 design/01 关闭自适应细分时,design/03 也应降低重网格频率
+
+---
+
+## 6. 调试工具
+
+### 6.1 可视化流动方向
+
+```cpp
+void ADynamicIronBlock::DebugDrawFlowDirections()
+{
+    FVector BoxHalfSize = GetBoxHalfSize();
+
+    // 在网格表面采样点
+    for (int32 VID : DynamicMesh->VertexIndicesItr())
+    {
+        if (VID % 100 != 0)  // 稀疏采样
+            continue;
+
+        FVector Pos = GetActorTransform().TransformPosition(DynamicMesh->GetVertex(VID));
+
+        // 计算流动方向
+        FVector ToNearestEdge = FindNearestFreeEdgeDirection(*DynamicMesh,
+            DynamicMesh->GetVertex(VID), BoxHalfSize);
+        FVector PrimaryFlow = CalculatePrimaryFlowDirection(FVector::DownVector, ToNearestEdge);
+
+        // 绘制方向箭头
+        DrawDebugDirectionalArrow(
+            GetWorld(),
+            Pos,
+            Pos + GetActorTransform().TransformVector(PrimaryFlow) * 5.0f,
+            2.0f,
+            FColor::Cyan,
+            false,
+            5.0f,
+            0,
+            0.5f
+        );
+    }
+}
+```
+
+### 6.2 可视化边缘顶点
+
+```cpp
+void ADynamicIronBlock::DebugDrawEdgeVertices()
+{
+    TSet<int32> EdgeVertices;
+    MarkEdgeVertices(*DynamicMesh, EdgeVertices, EdgeThreshold);
+
+    for (int32 VID : EdgeVertices)
+    {
+        FVector Pos = GetActorTransform().TransformPosition(DynamicMesh->GetVertex(VID));
+        DrawDebugPoint(GetWorld(), Pos, 8.0f, FColor::Red, false, 5.0f);
+    }
+}
+```
+
+---
+
+## 7. 已知限制与未来改进
+
+### 7.1 当前限制
+
+1. **极端形变**: 当边缘厚度<1mm 时,各向异性假设可能失效
+2. **拓扑变化**: 当前方法无法处理网格撕裂或融合(如锻打折叠)
+3. **多重边缘**: 复杂形状(如叉状)的方向检测可能不准确
+4. **斜向锤击**: §3.4 假设 HammerDir 通常为垂直(-Z),斜锤场景下 `FindNearestFreeEdgeDirection` 仍可用但 `PrimaryFlow` 的方向计算可能不符合玩家直觉。**当前 P2 暂缓**,见 §2.1 算法的 `HammerDir` 参数说明
+5. **体积守恒为可选项**: §2.5 推荐策略 B 软守恒,但默认关闭(`bEnableVolumeConservation = false`),需要显式启用才能获得物理直觉正确的形变
+6. **受影响三角形集合未导出**: §3.4 当前仅跟踪"边缘顶点",完整 `AffectedTriangles` 集合需扩展(参考 design/03 §8.2),才能完全支持 §3.5.3 方案 B 解耦调度
+
+### 7.2 未来改进方向
+
+- 基于曲率张量的精确流动方向(替代当前 BoxHalfSize 启发式)
+- 支持拓扑变化(网格切割与连接)
+- 多工具系统(不同锤头形状)
+- 严格体积守恒(策略 C,拉格朗日乘子法)
+- 增量式 BVH 更新(全量重建 → 仅受影响区域)
+- 斜向锤击支持(HammerDir 一般化处理)
+
+---
+
+## 8. 引用
+
+- 对应需求: [../requirements/01-锤击形变与刀刃形成需求.md](../requirements/01-锤击形变与刀刃形成需求.md)
+- 总体架构: [00-锻造系统总体技术架构.md](00-锻造系统总体技术架构.md)
+- 原始设计文档(归档): [../_archive/plans/2026-01-22-刀刃形成技术细节.md](../_archive/plans/2026-01-22-刀刃形成技术细节.md)
\ No newline at end of file
diff --git a/docs/design/02-表面磨损-顶点属性与无漂移采样设计.md b/docs/design/02-表面磨损-顶点属性与无漂移采样设计.md
new file mode 100644
index 0000000..81e1c40
--- /dev/null
+++ b/docs/design/02-表面磨损-顶点属性与无漂移采样设计.md
@@ -0,0 +1,635 @@
+# 表面磨损-顶点属性与无漂移采样设计
+
+**项目**: BladeSmith
+**文档类型**: 技术设计(专题)
+**版本**: 2.0
+**最后更新**: 2026-08-11
+**状态**: 整合自原 `2026-01-22-表面磨损系统细节.md`
+
+> 本文档描述表面磨损系统的顶点属性存储、无漂移纹理采样与材质实现。需求见 [requirements/02-表面磨损与外观需求.md](../requirements/02-表面磨损与外观需求.md)。总体架构见 [00-锻造系统总体技术架构.md](00-锻造系统总体技术架构.md)。
+
+---
+
+## 1. 技术背景
+
+铁锈层厚度0.1-2mm,成分为Fe₂O₃/Fe₃O₄,附着强度低易被机械摩擦去除。锤击压力导致摩擦力使铁锈层破碎脱落,塑性形变暴露新鲜金属表面,高温使部分氧化层还原。表面特征必须随形变一起移动,不能漂移。
+
+---
+
+## 2. 技术方案选择
+
+### 2.1 方案对比
+
+| 方案 | 分辨率 | 内存 | 性能 | 漂移问题 | 推荐度 |
+|------|--------|------|------|---------|--------|
+| **基于顶点** | ★★★☆☆ | ★★★★★ | ★★★★★ | ✅无 | ★★★★★ |
+| **基于纹理** | ★★★★★ | ★★☆☆☆ | ★★★☆☆ | ⚠️有扭曲 | ★★★☆☆ |
+| **基于体素** | ★★☆☆☆ | ★★★☆☆ | ★★★★☆ | ✅无 | ★★★☆☆ |
+
+**选择**: 基于顶点属性(方案A) + 程序化细节补充
+
+### 2.2 数据通道分配
+
+顶点颜色(RGBA) + UV1通道的完整编码方案:
+
+| 通道 | 用途 | 范围 | 更新频率 | 说明 |
+|------|------|------|---------|------|
+| **R** | 温度可视化 | 0-1 | 每帧 | 从体素采样,黑体辐射颜色 |
+| **G** | 打磨度(Polish) | 0-1 | 锤击时 | 0=完全生锈,1=完全光亮 |
+| **B** | 噪声种子(Seed) | 0-1 | 初始化 | 用于程序化噪声,固定不变 |
+| **A** | 硬度/应变 | 0-1 | 锤击时 | 可视化累积应变 |
+| **UV1.x** | 初始位置X | 0-1 | 初始化 | 编码3D位置的一部分 |
+| **UV1.y** | 初始位置Y | 0-1 | 初始化 | 编码3D位置的一部分 |
+
+额外数据通过自定义顶点属性存储。
+
+---
+
+## 3. 数据结构定义
+
+### 3.1 扩展顶点属性
+
+```cpp
+class ADynamicIronBlock
+{
+private:
+    // ===== 顶点自定义属性层 =====
+    TDynamicMeshVertexAttribute<FVector>* InitialPositions;  // 初始局部位置
+    TDynamicMeshVertexAttribute<float>* PolishAmount;        // 打磨度(0-1)
+    TDynamicMeshVertexAttribute<float>* RustSeed;           // 铁锈噪声种子
+    TDynamicMeshVertexAttribute<float>* OxideThickness;     // 氧化层厚度
+
+    // ===== 材质参数 =====
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Surface")
+    float RustRoughness = 0.9f;         // 铁锈粗糙度
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Surface")
+    float MetalRoughness = 0.2f;        // 金属粗糙度
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Surface")
+    FLinearColor RustBaseColor = FLinearColor(0.6f, 0.3f, 0.1f);  // 铁锈基色
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Surface")
+    FLinearColor MetalBaseColor = FLinearColor(0.8f, 0.8f, 0.85f); // 金属基色
+
+public:
+    // 初始化顶点属性
+    void InitializeVertexAttributes();
+};
+```
+
+### 3.2 初始化逻辑
+
+```cpp
+void ADynamicIronBlock::InitializeVertexAttributes()
+{
+    if (!DynamicMesh->HasMesh())
+        return;
+
+    DynamicMesh->EditMesh([&](FDynamicMesh3& Mesh)
+    {
+        // 确保属性系统已启用
+        if (!Mesh.HasAttributes())
+        {
+            Mesh.EnableAttributes();
+        }
+
+        // 创建自定义属性层
+        InitialPositions = new TDynamicMeshVertexAttribute<FVector>(&Mesh);
+        InitialPositions->Initialize(FVector::ZeroVector);
+
+        PolishAmount = new TDynamicMeshVertexAttribute<float>(&Mesh);
+        PolishAmount->Initialize(0.0f);
+
+        RustSeed = new TDynamicMeshVertexAttribute<float>(&Mesh);
+        RustSeed->Initialize(0.0f);
+
+        OxideThickness = new TDynamicMeshVertexAttribute<float>(&Mesh);
+        OxideThickness->Initialize(1.0f);  // 初始完全氧化
+
+        // 获取或创建UV1层
+        FDynamicMeshUVOverlay* UV1 = Mesh.Attributes()->GetUVLayer(1);
+        if (!UV1)
+        {
+            Mesh.Attributes()->SetNumUVLayers(2);
+            UV1 = Mesh.Attributes()->GetUVLayer(1);
+        }
+
+        // 计算包围盒(用于位置编码)
+        FAABB3 Box = Mesh.GetBounds();
+        FVector BoxMin = Box.Min;
+        FVector BoxMax = Box.Max;
+        FVector BoxSize = Box.Max - Box.Min;
+
+        // 初始化每个顶点
+        for (int32 VID : Mesh.VertexIndicesItr())
+        {
+            FVector LocalPos = Mesh.GetVertex(VID);
+
+            // 1. 保存初始位置(不变)
+            InitialPositions->SetValue(VID, LocalPos);
+
+            // 2. 初始化打磨度为0(完全生锈)
+            PolishAmount->SetValue(VID, 0.0f);
+
+            // 3. 分配随机铁锈种子
+            RustSeed->SetValue(VID, FMath::FRand());
+
+            // 4. 编码初始位置到UV1(仅X和Y)
+            FVector2f EncodedPos;
+            EncodedPos.X = (LocalPos.X - BoxMin.X) / (BoxSize.X + 1e-6f);
+            EncodedPos.Y = (LocalPos.Y - BoxMin.Y) / (BoxSize.Y + 1e-6f);
+            UV1->SetElement(VID, EncodedPos);
+
+            // 5. 编码初始位置Z到顶点颜色.B通道(替换随机种子方案)
+            FColor VertexColor = Mesh.GetVertexColor(VID);
+            FLinearColor LinearColor(VertexColor);
+            LinearColor.B = (LocalPos.Z - BoxMin.Z) / (BoxSize.Z + 1e-6f);  // Z坐标归一化
+            LinearColor.G = 0.0f;  // 初始打磨度
+            Mesh.SetVertexColor(VID, LinearColor.ToFColor());
+        }
+    });
+
+    // 更新材质参数
+    if (DynamicMaterialInstance)
+    {
+        DynamicMaterialInstance->SetScalarParameterValue(TEXT("RustRoughness"), RustRoughness);
+        DynamicMaterialInstance->SetScalarParameterValue(TEXT("MetalRoughness"), MetalRoughness);
+        DynamicMaterialInstance->SetVectorParameterValue(TEXT("RustColor"), RustBaseColor);
+        DynamicMaterialInstance->SetVectorParameterValue(TEXT("MetalColor"), MetalBaseColor);
+    }
+}
+```
+
+---
+
+## 4. 锤击更新逻辑
+
+### 4.1 打磨度更新
+
+```cpp
+void ADynamicIronBlock::OnHammerImpact(
+    FVector HitLocation,
+    FVector HitNormal,
+    float ImpactRadius,
+    float ImpactForce)
+{
+    FVector LocalHitPos = GetTransform().InverseTransformPosition(HitLocation);
+
+    DynamicMesh->EditMesh([&](FDynamicMesh3& Mesh)
+    {
+        for (int32 VID : Mesh.VertexIndicesItr())
+        {
+            FVector VertexPos = Mesh.GetVertex(VID);
+            float Distance = FVector::Dist(VertexPos, LocalHitPos);
+
+            // 只更新受击区域
+            if (Distance < ImpactRadius)
+            {
+                // 计算打磨强度
+                float DistanceRatio = Distance / ImpactRadius;
+                float FalloffExponent = 2.0f;
+                float Intensity = FMath::Pow(1.0f - DistanceRatio, FalloffExponent);
+
+                // 打磨强度与力度成正比
+                float PolishIncrease = Intensity * ImpactForce * 0.001f;  // 可调系数
+
+                // 累积打磨度(不可逆:只能增加,不能减少)
+                float CurrentPolish = PolishAmount->GetValue(VID);
+                float NewPolish = FMath::Min(1.0f, CurrentPolish + PolishIncrease);
+
+                PolishAmount->SetValue(VID, NewPolish);
+
+                // 同步到顶点颜色.G通道
+                FColor VertexColor = Mesh.GetVertexColor(VID);
+                FLinearColor LinearColor(VertexColor);
+                LinearColor.G = NewPolish;
+                Mesh.SetVertexColor(VID, LinearColor.ToFColor());
+
+                // 铁锈种子(顶点颜色.B)保持不变
+                // 初始位置Z(已在.B中)保持不变
+            }
+        }
+    });
+}
+```
+
+### 4.2 氧化层更新(可选)
+
+```cpp
+void ADynamicIronBlock::UpdateOxideLayer(float DeltaTime)
+{
+    if (!DynamicMesh->HasMesh())
+        return;
+
+    // 简化的氧化模型:
+    // - 高温(>300°C)时氧化加快
+    // - 打磨区域氧化较慢(新鲜表面)
+
+    DynamicMesh->EditMesh([&](FDynamicMesh3& Mesh)
+    {
+        for (int32 VID : Mesh.VertexIndicesItr())
+        {
+            float Temperature = SampleTemperatureAtVertex(Mesh, VID);
+            float Polish = PolishAmount->GetValue(VID);
+
+            // 氧化速率
+            float BaseOxidationRate = 0.01f;  // 基础速率
+            float TemperatureFactor = FMath::Clamp((Temperature - 300.0f) / 1000.0f, 0.0f, 1.0f);
+            float PolishProtection = 1.0f - Polish * 0.8f;  // 打磨后氧化慢
+
+            float OxidationRate = BaseOxidationRate * (1.0f + TemperatureFactor * 10.0f) * PolishProtection;
+
+            // 更新氧化层厚度
+            float CurrentOxide = OxideThickness->GetValue(VID);
+            float NewOxide = FMath::Min(1.0f, CurrentOxide + OxidationRate * DeltaTime);
+            OxideThickness->SetValue(VID, NewOxide);
+        }
+    });
+}
+```
+
+---
+
+## 5. 材质实现
+
+### 5.1 材质图表结构
+
+```
+[VertexColor] ────────┐
+                     ├─> [Polish = VertexColor.g]
+[TexCoord1] ─────────┘
+
+[Polish] ──> [Lerp]
+              ├─> [RustColor]  (Polish=0)
+              └─> [MetalColor] (Polish=1)
+
+[Polish] ──> [Lerp]
+              ├─> [RustRoughness] (0.9)
+              └─> [MetalRoughness] (0.2)
+
+[Polish] ──> [Lerp]
+              ├─> [RustMetallic] (0.0)
+              └─> [MetalMetallic] (1.0)
+
+[TextureCoordinate1] ──> [重建初始位置]
+                          ──> [噪声采样]
+                          ──> [铁锈图案]
+```
+
+### 5.2 HLSL实现(MF_SurfaceWear材质函数)
+
+```hlsl
+// 输入参数
+float3 WorldPosition;           // GetWorldPosition()
+float3 WorldNormal;            // GetWorldNormal()
+float4 VertexColor;            // GetVertexColor()
+float2 TexCoord1;              // GetTexCoord(1)
+
+// 材质参数(从材质实例传入)
+float3 RustColor;              // 铁锈颜色
+float3 MetalColor;             // 金属颜色
+float RustRoughness;           // 铁锈粗糙度
+float MetalRoughness;          // 金属粗糙度
+float RustMetallic;            // 铁锈金属度(通常0)
+float MetalMetallic;           // 金属金属度(通常1)
+
+// ===== 主函数 =====
+
+// 1. 读取打磨度
+float Polish = VertexColor.g;  // 来自G通道
+
+// 2. 重建初始位置(用于无漂移噪声采样)
+// 假设包围盒是 [-50, 50] cm
+float3 BoxMin = float3(-50.0, -50.0, -50.0);
+float3 BoxMax = float3(50.0, 50.0, 50.0);
+float3 BoxSize = BoxMax - BoxMin;
+
+float InitialPosX = TexCoord1.x * BoxSize.x + BoxMin.x;
+float InitialPosY = TexCoord1.y * BoxSize.y + BoxMin.y;
+float InitialPosZ = VertexColor.b * BoxSize.z + BoxMin.z;
+
+float3 InitialLocalPos = float3(InitialPosX, InitialPosY, InitialPosZ);
+
+// 3. 基于初始位置采样噪声(空间连续,无漂移)
+float RustSeedNoise = frac(InitialLocalPos.x * 0.1 + InitialLocalPos.y * 0.1 + InitialLocalPos.z * 0.1);
+float RustMacro = PseudoRandom(RustSeedNoise * 100.0);  // 宏观铁锈斑块
+float RustDetail = Noise(InitialLocalPos * 20.0);       // 细节纹理
+float RustMicro = Noise(InitialLocalPos * 100.0);       // 微观细节
+
+// 组合多层噪声
+float RustPattern = RustMacro * 0.6 + RustDetail * 0.3 + RustMicro * 0.1;
+
+// 4. 计算最终颜色、金属度、粗糙度
+float3 FinalRustColor = RustColor * (0.8 + RustPattern * 0.4);  // 铁锈颜色变化
+float3 FinalBaseColor = lerp(FinalRustColor, MetalColor, Polish);
+
+float FinalMetallic = lerp(RustMetallic, MetalMetallic, Polish);
+float FinalRoughness = lerp(RustRoughness, MetalRoughness, Polish);
+
+// 5. 可选:添加划痕细节(基于初始位置的高频噪声)
+float ScratchNoise = Noise(InitialLocalPos * 200.0) * 0.1;
+FinalRoughness += ScratchNoise * (1.0 - Polish);  // 划痕在未打磨区域更明显
+
+// 6. 输出
+return float4(FinalBaseColor, FinalRoughness, FinalMetallic, 1.0);
+```
+
+### 5.3 材质节点连接
+
+```
+材质输出:
+  Base Color ──> FinalBaseColor
+  Roughness ──> FinalRoughness
+  Metallic ──> FinalMetallic
+  Normal ───> [默认法线]
+  Ambient Occlusion ──> [可选]
+```
+
+---
+
+## 6. 无漂移保证机制
+
+### 6.1 问题示例
+
+**错误做法(会漂移)**:
+```hlsl
+// 基于世界坐标采样噪声
+float3 WorldPos = GetWorldPosition();
+float Rust = Noise(WorldPos * 10.0);
+
+// 问题:
+// 锻打前: 顶点A在(100, 50, 0),Noise → 0.3(铁锈)
+// 锻打后: 顶点A移动到(105, 52, 2),Noise → 0.8(变光亮?)
+// 铁锈"滑走"了!
+```
+
+### 6.2 正确做法(无漂移)
+
+**方案1:初始位置采样**
+```hlsl
+// 用初始的、不变的位置采样噪声
+float3 InitialLocalPos = ReconstructInitialPosition(TexCoord1, VertexColor.b);
+float Rust = Noise(InitialLocalPos * 10.0);
+
+// 优点:
+// - 顶点移动后,InitialLocalPos不变
+// - 铁锈图案"锁定"在材料上
+// - 空间连续:相邻顶点采样相似的噪声值
+```
+
+**方案2:种子采样**
+```hlsl
+// 用每个顶点的唯一种子采样
+float Seed = VertexColor.b;  // 0-1范围
+float Rust = PseudoRandom(Seed * 1000.0);
+
+// 优点:
+// - 完全无漂移
+// - 实现简单
+
+// 缺点:
+// - 空间不连续:相邻顶点可能有跳变
+// - 需要高网格密度掩盖
+```
+
+**推荐**:方案1(初始位置采样)
+
+### 6.3 完整的无漂移采样函数
+
+```hlsl
+/**
+ * 从UV1和顶点颜色重建初始位置
+ */
+float3 ReconstructInitialPosition(float2 TexCoord1, float EncodedZ)
+{
+    // 假设包围盒 [-50, 50] cm
+    float3 BoxMin = float3(-50.0, -50.0, -50.0);
+    float3 BoxSize = float3(100.0, 100.0, 100.0);
+
+    float InitialX = TexCoord1.x * BoxSize.x + BoxMin.x;
+    float InitialY = TexCoord1.y * BoxSize.y + BoxMin.y;
+    float InitialZ = EncodedZ * BoxSize.z + BoxMin.z;
+
+    return float3(InitialX, InitialY, InitialZ);
+}
+
+/**
+ * 采样铁锈图案(无漂移版本)
+ */
+float3 SampleRustPattern(float2 TexCoord1, float EncodedZ, float3 WorldNormal)
+{
+    // 重建初始位置
+    float3 InitialLocalPos = ReconstructInitialPosition(TexCoord1, EncodedZ);
+
+    // 多层噪声
+    float Rust1 = Noise(InitialLocalPos * 10.0 + float3(1.0, 2.0, 3.0));  // 低频
+    float Rust2 = Noise(InitialLocalPos * 30.0 + float3(4.0, 5.0, 6.0));  // 中频
+    float Rust3 = Noise(InitialLocalPos * 100.0 + float3(7.0, 8.0, 9.0)); // 高频
+
+    // 组合
+    float RustPattern = Rust1 * 0.5 + Rust2 * 0.3 + Rust3 * 0.2;
+
+    // 基于法线的变化(侧面铁锈更多)
+    float VerticalFactor = abs(WorldNormal.z);  // z=0表示侧面
+    RustPattern *= (0.7 + VerticalFactor * 0.3);
+
+    return RustPattern;
+}
+```
+
+---
+
+## 7. 高级特性
+
+### 7.1 大马士革钢层
+
+```cpp
+/**
+ * 标记大马士革层
+ * 在初始化时分配"材料ID"
+ */
+void InitializeDamascusLayers(FDynamicMesh3& Mesh)
+{
+    TDynamicMeshVertexAttribute<int32>* MaterialLayerID =
+        new TDynamicMeshVertexAttribute<int32>(&Mesh);
+
+    for (int32 VID : Mesh.VertexIndicesItr())
+    {
+        FVector Pos = Mesh.GetVertex(VID);
+
+        // 简化的层状分布:基于Z坐标
+        int32 LayerID = (int32)FMath::Floor(Pos.Z / 2.0f) % 2;  // 每2cm一层
+
+        MaterialLayerID->SetValue(VID, LayerID);
+    }
+}
+
+// 材质中基于LayerID选择颜色
+float3 GetDamascusColor(float3 InitialLocalPos, float LayerID)
+{
+    // 高碳钢层(深色)
+    float3 HighCarbonColor = float3(0.15, 0.1, 0.08);
+
+    // 低碳钢层(浅色)
+    float3 LowCarbonColor = float3(0.75, 0.7, 0.65);
+
+    // 混合过渡
+    float Mix = SmoothLayerPattern(InitialLocalPos);
+    return lerp(HighCarbonColor, LowCarbonColor, Mix);
+}
+```
+
+### 7.2 划痕系统
+
+```hlsl
+// 基于初始位置的各向异性噪声(模拟划痕)
+float3 InitialPos = ReconstructInitialPosition(TexCoord1, VertexColor.b);
+
+// 方向性划痕(沿着锤击方向)
+float ScratchDirection = InitialPos.x * 50.0;  // X方向划痕
+float ScratchPattern = Noise(float3(ScratchDirection, InitialPos.y * 20.0, 0.0));
+
+float3 ScratchColor = lerp(float3(1.0, 1.0, 1.0), BaseColor, ScratchPattern);
+float ScratchRoughness = Roughness * (1.0 + ScratchPattern * 0.5);
+
+// 仅在部分区域应用
+float ScratchMask = SmoothNoise(InitialPos * 15.0);
+FinalBaseColor = lerp(FinalBaseColor, ScratchColor, ScratchMask * 0.3);
+```
+
+### 7.3 水渍和氧化
+
+```hlsl
+// 淬火时的水渍痕迹
+float WaterStainMask = SampleWaterStainTexture(WorldPos);
+float3 PatinaColor = float3(0.3, 0.4, 0.5);  // 蓝绿色氧化
+
+// 仅在潮湿区域显示
+float HumidityFactor = 0.3;  // 可调
+FinalBaseColor = lerp(FinalBaseColor, FinalBaseColor * PatinaColor,
+                      WaterStainMask * HumidityFactor);
+```
+
+---
+
+## 8. 性能优化
+
+### 8.1 材质优化
+
+```hlsl
+// 早期退出优化
+float Polish = VertexColor.g;
+if (Polish > 0.95)
+{
+    // 完全打磨:直接返回金属色,跳过噪声计算
+    return MetalColor;
+}
+
+// LOD:基于距离减少噪声层数
+float DistanceToCamera = length(View.WorldPosition);
+int32 NoiseOctaves = DistanceToCamera < 100.0 ? 3 : 1;
+```
+
+### 8.2 顶点属性压缩
+
+如果内存紧张,可以压缩属性:
+
+```cpp
+// 打磨度:8位精度足够
+uint8 CompressedPolish = FMath::RoundToInt(PolishAmount * 255.0f);
+PolishAmount->SetValue(VID, CompressedPolish / 255.0f);
+
+// 初始位置:16位量化
+FVector QuantizedPos(
+    FMath::RoundToInt(LocalPos.X * 100.0f) / 100.0f,
+    FMath::RoundToInt(LocalPos.Y * 100.0f) / 100.0f,
+    FMath::RoundToInt(LocalPos.Z * 100.0f) / 100.0f
+);
+```
+
+---
+
+## 9. 调试与可视化
+
+### 9.1 可视化打磨度
+
+```cpp
+void ADynamicIronBlock::DebugDrawPolishHeatmap()
+{
+    if (!DynamicMesh->HasMesh())
+        return;
+
+    for (int32 VID : DynamicMesh->VertexIndicesItr())
+    {
+        if (VID % 50 != 0)  // 稀疏采样
+            continue;
+
+        float Polish = PolishAmount->GetValue(VID);
+        FVector WorldPos = GetActorTransform().TransformPosition(DynamicMesh->GetVertex(VID));
+
+        // 颜色映射:蓝色(0)→ 绿色(0.5)→ 红色(1.0)
+        FColor DebugColor = FMath::Lerp(
+            FColor::Blue,
+            FColor::Red,
+            Polish
+        );
+
+        DrawDebugPoint(GetWorld(), WorldPos, 5.0f, DebugColor, false, 5.0f);
+    }
+}
+```
+
+### 9.2 材质调试模式
+
+在材质中添加调试开关:
+
+```hlsl
+// 材质参数
+int32 DebugMode;  // 0=正常, 1=显示打磨度, 2=显示铁锈图案, 3=显示初始位置
+
+float3 DebugOutput;
+switch (DebugMode)
+{
+    case 1:  // 打磨度热图
+        DebugOutput = float3(Polish, 0.0, 1.0 - Polish);
+        break;
+    case 2:  // 铁锈图案
+        DebugOutput = RustPattern;
+        break;
+    case 3:  // 初始位置可视化
+        DebugOutput = frac(InitialLocalPos * 0.1);
+        break;
+    default:
+        DebugOutput = FinalBaseColor;
+        break;
+}
+
+return DebugOutput;
+```
+
+---
+
+## 10. 已知限制与未来改进
+
+### 10.1 当前限制
+
+1. **顶点密度瓶颈**: 20-50万顶点的细节仍不及2048²纹理
+2. **通道紧张**: 4个顶点颜色通道不够用,需要UV1补充
+3. **无物理反射**: 打磨效果仅通过粗糙度模拟,无真实光线追踪
+
+### 10.2 未来改进方向
+
+1. **混合方案**: 顶点属性(大区域) + 纹理细节(微观)
+2. **动态纹理**: 运行时更新高分辨率磨损纹理
+3. **程序化细节**: 材质中用噪声补充细节
+4. **多层材质**: 支持油污、涂层、水渍等多层效果
+5. **法线贴图**: 从打磨度生成动态法线贴图
+
+---
+
+## 11. 引用
+
+- 对应需求: [../requirements/02-表面磨损与外观需求.md](../requirements/02-表面磨损与外观需求.md)
+- 总体架构: [00-锻造系统总体技术架构.md](00-锻造系统总体技术架构.md)
+- 原始设计文档(归档): [../_archive/plans/2026-01-22-表面磨损系统细节.md](../_archive/plans/2026-01-22-表面磨损系统细节.md)
\ No newline at end of file
diff --git a/docs/design/03-网格质量-增量式优化设计.md b/docs/design/03-网格质量-增量式优化设计.md
new file mode 100644
index 0000000..8f89e88
--- /dev/null
+++ b/docs/design/03-网格质量-增量式优化设计.md
@@ -0,0 +1,1001 @@
+# 网格质量-增量式优化设计
+
+**项目**: BladeSmith
+**文档类型**: 技术设计(专题)
+**版本**: 2.0
+**最后更新**: 2026-08-11
+**状态**: 整合自原 `2026-01-22-网格质量优化细节.md`
+
+> 本文档描述网格质量优化的技术实现。需求见 [../requirements/03-网格质量与性能需求.md](../requirements/03-网格质量与性能需求.md)。总体架构见 [00-锻造系统总体技术架构.md](00-锻造系统总体技术架构.md)。
+
+---
+
+## 1. 技术背景
+
+在连续锻打过程中,动态网格会逐渐退化,导致视觉异常(着色条纹、闪烁)、性能下降(BVH查询效率降低50-80%)、数值不稳定(浮点误差累积、碰撞检测失效)。
+
+退化现象包括:
+- **细长三角形**: 长宽比>10:1,法线插值错误
+- **过小三角形**: 面积<0.01mm²,像素覆盖不足
+- **分布不均**: 密度相差100倍
+- **法线扭曲**: 相邻三角形法线夹角>90°
+
+---
+
+## 2. 增量式局部优化核心思想
+
+传统全局重建方法耗时50-100ms,且顶点属性可能丢失。增量式局部优化仅处理锤击影响区域,耗时5-15ms,保留所有顶点属性。
+
+```
+传统方法（全局重建）:
+锤击 → 全网格检测 → 全网格优化 → 重建BVH
+  ↓
+耗时50-100ms,顶点属性可能丢失
+
+增量优化（局部）:
+锤击 → 仅检测受影响区域 → 局部优化 → 局部BVH更新
+  ↓
+耗时5-15ms,保留所有顶点属性
+```
+
+---
+
+## 3. 优化三步法
+
+### 3.1 边翻转(Edge Flip)
+
+```
+Step 1: 边翻转（Edge Flip）
+┌───────┐     ┌───────┐
+│╱      │  →  │      ╲│  改善长宽比
+│╱      │     │      ╲│
+└───────┘     └───────┘
+```
+
+### 3.2 顶点平滑(Laplacian Smoothing)
+
+```
+Step 2: 顶点平滑（Laplacian Smoothing）
+●────●────●     ●────●────●
+    ╰─╯              │     均匀化分布
+```
+
+### 3.3 自适应重网格(Remeshing)
+
+```
+Step 3: 自适应重网格（Remeshing）
+  /\      /\     /\      /\   合并过大三角形
+ /__\    /__\ → /__\    /\__/   细分过小三角形
+```
+
+---
+
+## 4. 网格质量度量
+
+### 4.1 质量指标结构
+
+```cpp
+/**
+ * 三角形质量指标
+ */
+struct FTriangleQualityMetrics
+{
+    float Area;              // 面积（mm²）
+    float AspectRatio;       // 长宽比（0-1，1=正三角形）
+    float MinAngle;          // 最小内角（度）
+    float MaxAngle;          // 最大内角（度）
+    float EdgeLengthVariance;// 边长方差
+};
+```
+
+### 4.2 质量计算函数
+
+```cpp
+/**
+ * 计算三角形质量
+ */
+FTriangleQualityMetrics CalculateTriangleQuality(
+    const FDynamicMesh3& Mesh,
+    int32 TriangleID)
+{
+    FTriangleQualityMetrics Metrics;
+
+    // 获取三角形顶点
+    FIndex3i Tri = Mesh.GetTriangle(TriangleID);
+    FVector A = Mesh.GetVertex(Tri.A);
+    FVector B = Mesh.GetVertex(Tri.B);
+    FVector C = Mesh.GetVertex(Tri.C);
+
+    // 计算边长
+    float EdgeAB = FVector::Dist(A, B);
+    float EdgeBC = FVector::Dist(B, C);
+    float EdgeCA = FVector::Dist(C, A);
+
+    // 计算面积
+    FVector AB = B - A;
+    FVector AC = C - A;
+    Metrics.Area = FVector::CrossProduct(AB, AC).Size() * 0.5f;
+
+    // 计算长宽比
+    float MaxEdge = FMath::Max3(EdgeAB, EdgeBC, EdgeCA);
+    float MinEdge = FMath::Min3(EdgeAB, EdgeBC, EdgeCA);
+    Metrics.AspectRatio = MinEdge / (MaxEdge + 1e-6f);
+
+    // 计算内角（余弦定理）
+    Metrics.MaxAngle = FMath::RadiansToDegrees(FMath::Acos(
+        FMath::Clamp((EdgeBC*EdgeBC + EdgeCA*EdgeCA - EdgeAB*EdgeAB) / (2.0f * EdgeBC * EdgeCA),
+                     -1.0f, 1.0f)));
+
+    // 边长方差
+    float MeanEdge = (EdgeAB + EdgeBC + EdgeCA) / 3.0f;
+    Metrics.EdgeLengthVariance = (
+        FMath::Square(EdgeAB - MeanEdge) +
+        FMath::Square(EdgeBC - MeanEdge) +
+        FMath::Square(EdgeCA - MeanEdge)
+    ) / 3.0f;
+
+    return Metrics;
+}
+```
+
+### 4.3 退化三角形判断
+
+```cpp
+/**
+ * 判断三角形是否退化
+ */
+bool IsDegenerateTriangle(const FTriangleQualityMetrics& Metrics)
+{
+    return
+        Metrics.Area < 0.01f ||           // 面积太小
+        Metrics.AspectRatio < 0.1f ||      // 长宽比>10:1
+        Metrics.MaxAngle > 150.0f;         // 最大角>150度
+}
+```
+
+### 4.4 质量阈值配置
+
+```cpp
+class ADynamicIronBlock
+{
+    // 网格质量参数
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Quality")
+    float MinTriangleArea = 0.01f;         // 最小面积（mm²）
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Quality")
+    float MaxTriangleArea = 100.0f;        // 最大面积（mm²）
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Quality")
+    float MinAspectRatio = 0.1f;           // 最小长宽比
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Quality")
+    bool bAutoOptimizeMesh = true;         // 自动优化开关
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Quality")
+    float OptimizationRadius = 1.5f;       // 优化半径倍数（相对于ImpactRadius）
+};
+```
+
+---
+
+## 5. 边翻转优化
+
+### 5.1 算法原理
+
+```
+翻转前（质量差）：
+  C
+  │╲
+  │ ╲
+A─┼──B  ← 边AB
+  │ ╱
+  │╱
+  D
+
+质量指标：
+- 长宽比 = 0.08（很差）
+- 最大角 = 160°
+
+翻转后（改善）：
+  C
+  │╲
+  │ ╲
+ ╲  ╲   ← 新边CD
+  ╲  ╲
+   ╲  ╲
+    D──A──B  ← 边AB分成两条
+
+质量指标：
+- 长宽比 = 0.6（良好）
+- 最大角 = 80°
+```
+
+### 5.2 边翻转实现
+
+```cpp
+/**
+ * 边翻转优化
+ * 通过翻转边来改善三角形长宽比
+ */
+void FlipEdgesToImproveQuality(
+    FDynamicMesh3& Mesh,
+    const TSet<int32>& AffectedTriangles,
+    float MinAspectRatio)
+{
+    // 收集相关边
+    TSet<int32> EdgesToCheck;
+    for (int32 TID : AffectedTriangles)
+    {
+        FIndex3i TriEdges = Mesh.GetTriEdges(TID);
+        EdgesToCheck.Add(TriEdges.A);
+        EdgesToCheck.Add(TriEdges.B);
+        EdgesToCheck.Add(TriEdges.C);
+    }
+
+    int32 FlipCount = 0;
+
+    for (int32 EID : EdgesToCheck)
+    {
+        // 跳过边界边和内部边
+        if (!Mesh.IsEdge(EID) || Mesh.IsBoundaryEdge(EID))
+            continue;
+
+        // 获取边的两个三角形
+        FIndex2i EdgeTris = Mesh.GetEdgeT(EID);
+        if (EdgeTris.B == IndexConstants::InvalidID)
+            continue;  // 边界边，无法翻转
+
+        // 计算翻转前的质量
+        float QualityBefore = CalculateAspectRatio(Mesh, EdgeTris.A) +
+                              CalculateAspectRatio(Mesh, EdgeTris.B);
+
+        // 尝试翻转
+        FDynamicMesh3::FEdgeFlipInfo FlipInfo;
+        EMeshResult Result = Mesh.FlipEdge(EID, FlipInfo);
+
+        if (Result == EMeshResult::Ok)
+        {
+            // 计算翻转后的质量
+            float QualityAfter = CalculateAspectRatio(Mesh, EdgeTris.A) +
+                                 CalculateAspectRatio(Mesh, EdgeTris.B);
+
+            // 如果质量没有改善，翻转回去
+            if (QualityAfter <= QualityBefore)
+            {
+                Mesh.FlipEdge(EID, FlipInfo);  // 撤销
+            }
+            else
+            {
+                FlipCount++;
+            }
+        }
+    }
+
+    //UE_LOG(LogBladeSmith, Log, TEXT("Flipped %d edges"), FlipCount);
+}
+```
+
+### 5.3 长宽比计算
+
+```cpp
+/**
+ * 计算单个三角形的长宽比
+ */
+float CalculateAspectRatio(const FDynamicMesh3& Mesh, int32 TriID)
+{
+    FIndex3i Tri = Mesh.GetTriangle(TriID);
+    FVector A = Mesh.GetVertex(Tri.A);
+    FVector B = Mesh.GetVertex(Tri.B);
+    FVector C = Mesh.GetVertex(Tri.C);
+
+    float EdgeAB = FVector::Dist(A, B);
+    float EdgeBC = FVector::Dist(B, C);
+    float EdgeCA = FVector::Dist(C, A);
+
+    float MaxEdge = FMath::Max3(EdgeAB, EdgeBC, EdgeCA);
+    float MinEdge = FMath::Min3(EdgeAB, EdgeBC, EdgeCA);
+
+    return MinEdge / (MaxEdge + 1e-6f);
+}
+```
+
+---
+
+## 6. 顶点平滑
+
+### 6.1 Laplacian平滑原理
+
+Laplacian平滑将每个顶点移向邻居的平均位置。
+
+```
+平滑前：
+    ●
+   ╱ ╲  不规则分布
+  ●   ●
+
+平滑后（每个顶点移向邻居的平均位置）：
+    ●
+   │ ╲  均匀分布
+   │  ╲
+  ●───●
+
+公式：
+V_new = V_old + λ × (Σ(V_neighbor) / N - V_old)
+
+其中：
+λ = 平滑系数（0-1）
+N = 邻居顶点数量
+```
+
+### 6.2 Laplacian平滑实现
+
+```cpp
+/**
+ * Laplacian顶点平滑
+ * 均匀化顶点分布，改善网格质量
+ */
+void SmoothVertices(
+    FDynamicMesh3& Mesh,
+    const TSet<int32>& AffectedTriangles,
+    int32 Iterations,
+    float SmoothFactor)
+{
+    if (Iterations <= 0)
+        return;
+
+    // 收集需要平滑的顶点
+    TSet<int32> VerticesToSmooth;
+    for (int32 TID : AffectedTriangles)
+    {
+        FIndex3i Tri = Mesh.GetTriangle(TID);
+        VerticesToSmooth.Add(Tri.A);
+        VerticesToSmooth.Add(Tri.B);
+        VerticesToSmooth.Add(Tri.C);
+    }
+
+    // 排除边界顶点（保持形状）
+    TSet<int32> InteriorVertices;
+    for (int32 VID : VerticesToSmooth)
+    {
+        if (!Mesh.IsBoundaryVertex(VID))
+        {
+            InteriorVertices.Add(VID);
+        }
+    }
+
+    // 迭代平滑
+    for (int32 Iter = 0; Iter < Iterations; ++Iter)
+    {
+        TMap<int32, FVector> NewPositions;
+
+        for (int32 VID : InteriorVertices)
+        {
+            // 获取邻接顶点
+            TArray<int32> Neighbors;
+            for (int32 NbrVID : Mesh.VtxVerticesItr(VID))
+            {
+                Neighbors.Add(NbrVID);
+            }
+
+            if (Neighbors.Num() == 0)
+                continue;
+
+            // 计算平均位置
+            FVector Sum = FVector::ZeroVector;
+            for (int32 NbrVID : Neighbors)
+            {
+                Sum += Mesh.GetVertex(NbrVID);
+            }
+            FVector AvgPos = Sum / Neighbors.Num();
+
+            // Laplacian平滑
+            FVector CurrentPos = Mesh.GetVertex(VID);
+            FVector NewPos = FMath::Lerp(CurrentPos, AvgPos, SmoothFactor);
+
+            NewPositions.Add(VID, NewPos);
+        }
+
+        // 批量更新位置
+        for (const auto& Pair : NewPositions)
+        {
+            Mesh.SetVertex(Pair.Key, Pair.Value);
+        }
+    }
+}
+```
+
+### 6.3 加权平滑(保留特征)
+
+根据曲率调整平滑强度,高曲率区域少平滑以保留锐利特征。
+
+```cpp
+/**
+ * 特征保留的加权平滑
+ * 根据曲率调整平滑强度：高曲率区域少平滑
+ */
+void WeightedSmoothVertices(
+    FDynamicMesh3& Mesh,
+    const TSet<int32>& AffectedTriangles,
+    float BaseSmoothFactor)
+{
+    TMap<int32, FVector> NewPositions;
+
+    for (int32 VID : AffectedTriangles)
+    {
+        if (Mesh.IsBoundaryVertex(VID))
+            continue;
+
+        // 计算局部曲率
+        float Curvature = CalculateVertexCurvature(Mesh, VID);
+
+        // 高曲率区域平滑系数小（保留锐利特征）
+        float AdaptiveSmoothFactor = BaseSmoothFactor / (1.0f + Curvature * 5.0f);
+
+        // ... 其余逻辑同Laplacian平滑
+    }
+}
+```
+
+### 6.4 顶点曲率计算
+
+```cpp
+/**
+ * 计算顶点曲率（简化：基于邻面法线方差）
+ */
+float CalculateVertexCurvature(const FDynamicMesh3& Mesh, int32 VID)
+{
+    TArray<int32> Triangles;
+    for (int32 TID : Mesh.VtxTrianglesItr(VID))
+    {
+        Triangles.Add(TID);
+    }
+
+    if (Triangles.Num() < 2)
+        return 0.0f;
+
+    // 计算平均法线
+    FVector AverageNormal = FVector::ZeroVector;
+    for (int32 TID : Triangles)
+    {
+        AverageNormal += Mesh.GetTriNormal(TID);
+    }
+    AverageNormal /= Triangles.Num();
+
+    // 计算法线方差
+    float Variance = 0.0f;
+    for (int32 TID : Triangles)
+    {
+        FVector TriNormal = Mesh.GetTriNormal(TID);
+        Variance += FVector::DistSquared(TriNormal, AverageNormal);
+    }
+    Variance /= Triangles.Num();
+
+    return FMath::Sqrt(Variance);
+}
+```
+
+---
+
+## 7. 自适应重网格
+
+### 7.1 使用UE5的FRemesher
+
+```cpp
+#include "MeshSimplification.h"
+#include "Remesher.h"
+
+/**
+ * 局部自适应重网格
+ * 使用FRemesher自动细分和合并三角形
+ */
+void RemeshRegion(
+    FDynamicMesh3& Mesh,
+    const TSet<int32>& AffectedTriangles,
+    float TargetEdgeLength)
+{
+    // 创建Remesher
+    FRemesher Remesher(&Mesh);
+
+    // 配置Remesher
+    Remesher.bEnableSplits = true;        // 允许边细分
+    Remesher.bEnableCollapses = true;     // 允许边合并
+    Remesher.bEnableFlips = true;         // 允许边翻转
+    Remesher.bEnableSmoothing = true;     // 允许平滑
+    Remesher.bPreventNormalFlips = true;  // 防止法线反转
+
+    // 设置目标边长
+    Remesher.SetTargetEdgeLength(TargetEdgeLength);
+    Remesher.SetMinEdgeLength(TargetEdgeLength * 0.5f);
+    Remesher.SetMaxEdgeLength(TargetEdgeLength * 2.0f);
+
+    // 限制重网格化到受影响区域
+    // 方法1: 使用投影约束
+    for (int32 TID : AffectedTriangles)
+    {
+        Remesher.ProjectionTarget.AddTriangle(TID);
+    }
+
+    // 执行重网格化（限制迭代次数）
+    int32 MaxIterations = 5;
+    for (int32 i = 0; i < MaxIterations; ++i)
+    {
+        Remesher.BasicRemeshPass();
+
+        // 检查是否收敛
+        float AvgEdgeLength = CalculateAverageEdgeLength(Mesh, AffectedTriangles);
+        if (FMath::Abs(AvgEdgeLength - TargetEdgeLength) < TargetEdgeLength * 0.1f)
+        {
+            break;
+        }
+    }
+}
+```
+
+### 7.2 平均边长计算
+
+```cpp
+/**
+ * 计算平均边长
+ */
+float CalculateAverageEdgeLength(
+    const FDynamicMesh3& Mesh,
+    const TSet<int32>& Triangles)
+{
+    float TotalLength = 0.0f;
+    int32 Count = 0;
+
+    TSet<int32> ProcessedEdges;
+
+    for (int32 TID : Triangles)
+    {
+        FIndex3i Edges = Mesh.GetTriEdges(TID);
+
+        for (int32 i = 0; i < 3; ++i)
+        {
+            int32 EID = Edges[i];
+            if (!ProcessedEdges.Contains(EID))
+            {
+                ProcessedEdges.Add(EID);
+
+                FIndex2i EdgeVerts = Mesh.GetEdgeV(EID);
+                FVector V0 = Mesh.GetVertex(EdgeVerts.A);
+                FVector V1 = Mesh.GetVertex(EdgeVerts.B);
+
+                TotalLength += FVector::Dist(V0, V1);
+                Count++;
+            }
+        }
+    }
+
+    return Count > 0 ? (TotalLength / Count) : 1.0f;
+}
+```
+
+### 7.3 保留顶点属性
+
+重网格化会改变顶点ID,需要重新插值属性。
+
+#### 方法1: 保存/恢复属性
+
+```cpp
+/**
+ * 保存当前顶点属性
+ */
+TMap<int32, FVertexAttributes> SaveVertexAttributes(const FDynamicMesh3& Mesh)
+{
+    TMap<int32, FVertexAttributes> AttributeMap;
+
+    for (int32 VID : Mesh.VertexIndicesItr())
+    {
+        FVertexAttributes Attr;
+        Attr.Position = Mesh.GetVertex(VID);
+        Attr.Color = Mesh.GetVertexColor(VID);
+        // ... 其他属性
+
+        AttributeMap.Add(VID, Attr);
+    }
+
+    return AttributeMap;
+}
+
+/**
+ * 重网格化后插值属性
+ */
+void RestoreVertexAttributes(
+    FDynamicMesh3& Mesh,
+    const TMap<int32, FVertexAttributes>& OldAttributes)
+{
+    // 简化：最近邻插值
+    for (int32 NewVID : Mesh.VertexIndicesItr())
+    {
+        FVector NewPos = Mesh.GetVertex(NewVID);
+
+        // 找最近的旧顶点
+        int32 BestVID = IndexConstants::InvalidID;
+        float MinDist = TNumericLimits<float>::Max();
+
+        for (const auto& Pair : OldAttributes)
+        {
+            float Dist = FVector::Dist(NewPos, Pair.Value.Position);
+            if (Dist < MinDist)
+            {
+                MinDist = Dist;
+                BestVID = Pair.Key;
+            }
+        }
+
+        if (BestVID != IndexConstants::InvalidID)
+        {
+            const FVertexAttributes& OldAttr = OldAttributes[BestVID];
+            Mesh.SetVertexColor(NewVID, OldAttr.Color);
+            // ... 其他属性
+        }
+    }
+}
+```
+
+#### 方法2: 使用重网格化回调(推荐)
+
+```cpp
+// FRemesher支持回调，可以在顶点创建/删除时插值属性
+Remesher.OnVertexSplit.AddLambda(
+    [&](int32 OriginalVID, int32 NewVID, float SplitAlpha)
+    {
+        // 插值属性
+        float Polish0 = PolishAmount->GetValue(OriginalVID);
+        float Polish1 = /* 邻接顶点的Polish */;
+        PolishAmount->SetValue(NewVID, FMath::Lerp(Polish0, Polish1, SplitAlpha));
+    });
+```
+
+---
+
+## 8. 完整优化流程
+
+### 8.1 集成到锤击事件
+
+```cpp
+void ADynamicIronBlock::OnHammerImpact(
+    FVector HitLocation,
+    FVector HitNormal,
+    float ImpactRadius,
+    float ImpactDepth,
+    float ImpactForce)
+{
+    FVector LocalHitPos = GetTransform().InverseTransformPosition(HitLocation);
+
+    double StartTime = FPlatformTime::Seconds();
+
+    DynamicMesh->EditMesh([&](FDynamicMesh3& Mesh)
+    {
+        // ===== 1. 执行形变 =====
+        ApplyAnisotropicDeformation(Mesh, LocalHitPos, ImpactRadius, ...);
+
+        // ===== 2. 网格质量优化 =====
+        if (bAutoOptimizeMesh)
+        {
+            // 找到受影响的三角形
+            TSet<int32> AffectedTriangles = FindAffectedTriangles(Mesh, LocalHitPos, ImpactRadius);
+
+            if (AffectedTriangles.Num() > 0)
+            {
+                // Step 1: 边翻转
+                FlipEdgesToImproveQuality(Mesh, AffectedTriangles, MinAspectRatio);
+
+                // Step 2: 顶点平滑
+                SmoothVertices(Mesh, AffectedTriangles, 2, 0.5f);
+
+                // Step 3: 自适应重网格（每隔几次执行）
+                static int32 RemeshCounter = 0;
+                if (++RemeshCounter % 5 == 0)
+                {
+                    float TargetEdgeLength = CalculateAverageEdgeLength(Mesh, AffectedTriangles);
+                    RemeshRegion(Mesh, AffectedTriangles, TargetEdgeLength);
+                }
+            }
+        }
+
+        // ===== 3. 更新顶点颜色（温度、打磨度）=====
+        UpdateVertexColors(Mesh);
+    });
+
+    // ===== 4. 重建BVH =====
+    GenerateBVH();
+
+    double ElapsedTime = (FPlatformTime::Seconds() - StartTime) * 1000.0;
+    //UE_LOG(LogBladeSmith, Log, TEXT("Hammer impact + optimization: %.2f ms"), ElapsedTime);
+}
+```
+
+### 8.2 受影响三角形查找
+
+```cpp
+/**
+ * 找到受锤击影响的三角形
+ */
+TSet<int32> ADynamicIronBlock::FindAffectedTriangles(
+    const FDynamicMesh3& Mesh,
+    FVector Center,
+    float Radius) const
+{
+    TSet<int32> AffectedTriangles;
+
+    for (int32 TID : Mesh.TriangleIndicesItr())
+    {
+        FVector Centroid = Mesh.GetTriCentroid(TID);
+        if (FVector::Dist(Centroid, Center) < Radius * OptimizationRadius)
+        {
+            AffectedTriangles.Add(TID);
+        }
+    }
+
+    return AffectedTriangles;
+}
+```
+
+---
+
+## 9. 性能分析
+
+### 9.1 计算复杂度
+
+| 操作 | 时间复杂度 | 空间复杂度 | 实际耗时(20万顶点) |
+|------|-----------|-----------|---------------------|
+| 边翻转 | O(E×K) | O(E) | 3-5ms |
+| 顶点平滑 | O(N×K×V) | O(N) | 2-3ms |
+| 重网格化 | O(E×log E) | O(E) | 5-10ms |
+| **总计** | - | - | **10-18ms** |
+
+其中:
+- N = 顶点数(20万)
+- E = 边数(约3万)
+- K = 迭代次数(2-5)
+- V = 平均邻接顶点数(6-8)
+
+### 9.2 优化策略
+
+#### 策略1: 限制优化区域
+
+```cpp
+// 仅优化距离锤击中心 < OptimizationRadius × ImpactRadius 的区域
+float OptimizationRadius = 1.5f;  // 仅优化150%影响半径内
+
+// 效果：优化区域减少60%，耗时减少50%
+```
+
+#### 策略2: 降低重网格频率
+
+```cpp
+// 每5次锤击才重网格一次
+if (++RemeshCounter % 5 == 0)
+{
+    RemeshRegion(...);
+}
+
+// 效果：平均耗时减少40%
+```
+
+#### 策略3: 质量阈值触发
+
+```cpp
+// 仅当网格质量低于阈值时才优化
+float AverageQuality = CalculateAverageMeshQuality(Mesh, AffectedTriangles);
+if (AverageQuality < QualityThreshold)
+{
+    OptimizeMeshQuality(...);
+}
+
+// 效果：仅必要时优化，平均耗时减少70%
+```
+
+#### 策略4: 分帧处理
+
+```cpp
+// 将重网格化分散到多帧
+if (bPendingRemesh)
+{
+    RemeshRegion(...);  // 执行一小部分
+    if (!IsRemeshComplete())
+    {
+        // 下一帧继续
+        GetWorldTimerManager().SetTimerForNextTick(this, &ThisClass::ContinueRemesh);
+    }
+}
+```
+
+---
+
+## 10. 调试与可视化
+
+### 10.1 可视化退化三角形
+
+```cpp
+void ADynamicIronBlock::DebugDrawDegenerateTriangles()
+{
+    if (!DynamicMesh->HasMesh())
+        return;
+
+    for (int32 TID : DynamicMesh->TriangleIndicesItr())
+    {
+        FTriangleQualityMetrics Quality = CalculateTriangleQuality(*DynamicMesh, TID);
+
+        if (IsDegenerateTriangle(Quality))
+        {
+            // 绘制退化三角形（红色）
+            FIndex3i Tri = DynamicMesh->GetTriangle(TID);
+            FVector A = GetActorTransform().TransformPosition(DynamicMesh->GetVertex(Tri.A));
+            FVector B = GetActorTransform().TransformPosition(DynamicMesh->GetVertex(Tri.B));
+            FVector C = GetActorTransform().TransformPosition(DynamicMesh->GetVertex(Tri.C));
+
+            DrawDebugLine(GetWorld(), A, B, FColor::Red, false, 5.0f, 0, 2.0f);
+            DrawDebugLine(GetWorld(), B, C, FColor::Red, false, 5.0f, 0, 2.0f);
+            DrawDebugLine(GetWorld(), C, A, FColor::Red, false, 5.0f, 0, 2.0f);
+        }
+    }
+}
+```
+
+### 10.2 可视化网格质量热图
+
+```cpp
+void ADynamicIronBlock::DebugDrawQualityHeatmap()
+{
+    if (!DynamicMesh->HasMesh())
+        return;
+
+    for (int32 TID : DynamicMesh->TriangleIndicesItr())
+    {
+        if (TID % 10 != 0)  // 稀疏采样
+            continue;
+
+        float Quality = CalculateAspectRatio(*DynamicMesh, TID);
+
+        // 颜色映射：蓝色（好）→ 绿色（中）→ 红色（差）
+        FColor HeatColor;
+        if (Quality > 0.5f)
+        {
+            HeatColor = FLinearColor::LerpUsingHSV(FColor::Green, FColor::Blue,
+                (Quality - 0.5f) / 0.5f).ToFColor();
+        }
+        else
+        {
+            HeatColor = FLinearColor::LerpUsingHSV(FColor::Red, FColor::Green,
+                Quality / 0.5f).ToFColor();
+        }
+
+        FIndex3i Tri = DynamicMesh->GetTriangle(TID);
+        FVector Center = GetActorTransform().TransformPosition(DynamicMesh->GetTriCentroid(TID));
+
+        DrawDebugPoint(GetWorld(), Center, 5.0f, HeatColor, false, 5.0f);
+    }
+}
+```
+
+### 10.3 性能统计
+
+```cpp
+void ADynamicIronBlock::LogMeshQualityStats()
+{
+    if (!DynamicMesh->HasMesh())
+        return;
+
+    // 统计质量指标
+    int32 TotalTriangles = DynamicMesh->TriangleCount();
+    int32 DegenerateCount = 0;
+    float TotalAspectRatio = 0.0f;
+    float TotalArea = 0.0f;
+
+    for (int32 TID : DynamicMesh->TriangleIndicesItr())
+    {
+        FTriangleQualityMetrics Quality = CalculateTriangleQuality(*DynamicMesh, TID);
+
+        TotalAspectRatio += Quality.AspectRatio;
+        TotalArea += Quality.Area;
+
+        if (IsDegenerateTriangle(Quality))
+        {
+            DegenerateCount++;
+        }
+    }
+
+    float AvgAspectRatio = TotalAspectRatio / TotalTriangles;
+    float DegenerateRatio = (float)DegenerateCount / TotalTriangles;
+
+    UE_LOG(LogBladeSmith, Warning,
+        TEXT("Mesh Quality: AvgAspectRatio=%.3f, Degenerate=%.1f%%"),
+        AvgAspectRatio,
+        DegenerateRatio * 100.0f
+    );
+}
+```
+
+---
+
+## 11. 参数调优指南
+
+### 11.1 不同场景的推荐参数
+
+#### 锻造平面(大范围形变)
+
+```cpp
+MinTriangleArea = 0.5f;         // 允许较大三角形
+MaxTriangleArea = 200.0f;
+MinAspectRatio = 0.15f;         // 放宽长宽比要求
+OptimizationRadius = 2.0f;      // 大范围优化
+SmoothIterations = 2;
+RemeshFrequency = 10;           // 低频重网格
+```
+
+#### 锻造边缘(精细形变)
+
+```cpp
+MinTriangleArea = 0.01f;        // 高质量要求
+MaxTriangleArea = 50.0f;
+MinAspectRatio = 0.2f;          // 严格长宽比
+OptimizationRadius = 1.2f;      // 局部优化
+SmoothIterations = 3;
+RemeshFrequency = 5;            // 高频重网格
+```
+
+#### 性能优先模式
+
+```cpp
+MinTriangleArea = 1.0f;         // 放宽质量要求
+MaxTriangleArea = 500.0f;
+MinAspectRatio = 0.05f;         // 允许严重退化
+OptimizationRadius = 1.0f;
+SmoothIterations = 1;
+RemeshFrequency = 20;           // 极低频重网格
+```
+
+### 11.2 自动调参
+
+```cpp
+/**
+ * 根据当前帧率自动调整优化强度
+ */
+void AutoAdjustOptimizationSettings()
+{
+    float CurrentFPS = GetWorld()->GetDeltaSeconds();
+
+    if (CurrentFPS < 30.0f)
+    {
+        // 帧率低：降低优化频率
+        RemeshFrequency = FMath::Min(RemeshFrequency + 1, 20);
+        OptimizationRadius = FMath::Max(OptimizationRadius - 0.1f, 1.0f);
+    }
+    else if (CurrentFPS > 55.0f)
+    {
+        // 帧率高：提高质量
+        RemeshFrequency = FMath::Max(RemeshFrequency - 1, 3);
+        OptimizationRadius = FMath::Min(OptimizationRadius + 0.1f, 2.0f);
+    }
+}
+```
+
+---
+
+## 12. 已知限制与未来改进
+
+### 12.1 当前限制
+
+1. **属性插值精度**: 重网格化后顶点属性需要插值,可能有精度损失
+2. **BVH重建开销**: 每次形变后重建BVH仍需5-10ms
+3. **极端形变**: 当形变超过50%时,优化效果显著下降
+4. **拓扑变化**: 无法处理网格撕裂、融合等拓扑变化
+
+### 12.2 未来改进方向
+
+1. **增量式BVH更新**: 仅更新受影响区域的BVH节点
+2. **GPU加速优化**: 将边翻转、平滑放到Compute Shader
+3. **自适应优化频率**: 基于退化程度动态调整
+4. **多线程并行**: 独立区域可以并行优化
+5. **预测性优化**: 在锤击前预测退化区域并提前优化
+
+---
+
+## 13. 引用
+
+- 对应需求: [../requirements/03-网格质量与性能需求.md](../requirements/03-网格质量与性能需求.md)
+- 总体架构: [00-锻造系统总体技术架构.md](00-锻造系统总体技术架构.md)
+- 原始设计文档(归档): [../_archive/plans/2026-01-22-网格质量优化细节.md](../_archive/plans/2026-01-22-网格质量优化细节.md)
\ No newline at end of file