当前位置：首页 > news >正文

Unity高性能碰撞检测：Burst+SAT算法实现与优化

news 2026/8/7 13:16:27

1. 项目概述：当碰撞检测成为性能瓶颈

在Unity游戏开发中，物理系统是连接虚拟世界与现实逻辑的桥梁，而碰撞检测则是这座桥梁的基石。无论是开放世界中的角色与环境互动，还是弹幕射击游戏里密集的子弹判定，碰撞检测的性能直接决定了游戏的流畅度与体验上限。然而，Unity内置的物理引擎（PhysX）虽然功能强大，但在处理大规模、高频率或自定义形状的碰撞检测时，尤其是在移动平台或WebGL等性能受限的环境下，常常会成为CPU的沉重负担。你可能会遇到游戏帧率骤降、手机发烫，或者在Unity WebGL初始化很久、程序打开黑屏无响应等问题，其根源之一可能就是低效的碰撞检测逻辑。

这正是“用Burst+SAT算法实现高性能3D碰撞检测”这个项目的核心价值所在。它不是一个简单的功能实现，而是一套针对特定高性能需求场景的、从算法底层到编译执行层的深度优化方案。简单来说，我们绕开PhysX的通用性包袱，针对“凸多面体”这类在游戏中极其常见的形状（如角色、载具、大部分道具），使用分离轴定理（SAT）这一经典几何算法进行精确碰撞判断，并借助Unity的Burst编译器将C#代码编译成高度优化的原生机器码，从而在CPU上榨取出极致的性能。这尤其适用于需要实时处理成千上万个碰撞体（如大量子弹、粒子、小物件）的场景，或是那些对物理模拟有自定义需求的项目。

2. 核心思路与方案选型：为什么是SAT+Burst？

在决定动手之前，我们需要回答几个关键问题：为什么不用现成的？为什么选SAT算法？Burst又能带来什么？这背后的选型逻辑，直接决定了方案的成败。

2.1 通用方案之痛与定制化需求

Unity内置的Collider组件（Box, Sphere, Mesh等）配合Rigidbody，是开发者的首选。它们稳定、易用，与引擎深度集成。但在高性能需求面前，其局限性凸显：

性能开销：每个Collider都需要PhysX引擎进行管理，即使两个物体距离很远，也可能参与粗检测阶段。当物体数量（N）很大时，复杂度接近O(N²)的粗检测就会成为瓶颈。
灵活性不足：对于非标准形状，我们通常使用Mesh Collider，但其性能最差，且无法进行高效的连续碰撞检测（CCD）配置。对于需要特殊碰撞响应逻辑（如完全弹性碰撞）的情况，深入修改PhysX底层极为困难。
托管层开销：Unity的物理计算在C++层（PhysX），但每帧都需要在C#托管层和Native层之间进行大量数据交换（如获取碰撞结果、修改状态），这会产生额外的开销。

因此，当你的游戏是弹幕游戏、拥有大量可交互小物件、或是需要服务器端高效进行物理验证时，一套自研的、轻量级的高性能碰撞检测系统就成为了必须品。

2.2 算法基石：分离轴定理（SAT）的得与失

在众多碰撞检测算法中，我们选择了分离轴定理（Separating Axis Theorem, SAT）。它的核心思想非常直观：如果能找到一条轴线，使得两个凸多面体在该轴线上的投影不重叠，那么这两个物体就一定没有碰撞。我们需要在所有潜在的分离轴（通常来自两个物体的每个面的法线以及每条边的叉积方向）上进行投影测试。

选择SAT的理由：

精确性：对于凸多面体，SAT能给出布尔型的精确碰撞结果（是/否），这对于需要确定性的游戏逻辑至关重要。
原理相对直观：算法步骤清晰，易于实现、调试和可视化，方便开发者理解并在此基础上扩展（如获取碰撞法线、穿透深度）。
适用于凸体：游戏中绝大多数规则物体和简化后的模型都是凸体，SAT完全胜任。

SAT的挑战与应对：

计算复杂度：对于有m个面和n个面的两个凸多面体，潜在的分离轴数量为O(m+n+mn)。直接实现可能很慢。优化点在于：提前计算并缓存物体的面法线、边方向；利用向量运算的SIMD（单指令多数据）潜力；以及尽早跳出（Early-out），一旦找到一条分离轴就立即返回“无碰撞”。
只适用于凸体：这是SAT的根本限制。对于凹体，需要先分解为凸体集合（凸包分解）。网络热词中提到的“凸包碰撞检测逻辑”正是与此相关的前置步骤。

2.3 性能核弹：Burst编译器的赋能

有了高效的算法，还需要极致的执行效率。这就是Burst编译器登场的时候。Burst是Unity的DOTS（面向数据的技术栈）生态中的核心组件，它可以将符合其约束的C#代码（通常是使用Unity.Burst命名空间下类型和[BurstCompile]特性的Job）编译成高度优化的、利用目标平台SIMD指令集的本地代码。

Burst带来的质变：

消除托管开销：Burst编译的代码直接在Native层运行，避免了C#虚拟机和垃圾回收（GC）带来的开销。这对于每帧需要执行数十万次向量点积、叉积运算的SAT算法来说，性能提升是数量级的。
自动SIMD向量化：Burst编译器能够自动将循环中的标量运算转换为SIMD指令，例如同时计算四个投影值。这对于SAT算法中大量的向量点乘操作是完美的加速。
内存访问优化：结合Unity的ECS（实体组件系统）或NativeArray，可以确保数据在内存中连续排布，最大化CPU缓存命中率，进一步压榨性能。

将SAT算法用Burst Job来实现，意味着我们将一个纯算法的优势，与硬件底层执行效率的优势结合了起来。这解决了“Unity WebGL初始化很久”或“打包Android后卡顿”等性能问题中，可能由脚本逻辑效率低下所导致的那一部分。

3. 系统设计与核心数据结构

在敲代码之前，良好的设计是成功的一半。我们需要设计一套既能高效存储凸多面体数据，又能与Burst Job友好交互的数据结构。

3.1 凸多面体的数据表示

一个凸多面体在计算中，我们最关心它的顶点（Vertices）、面（Faces）和边（Edges）。为了在SAT中使用，我们需要面的法线（Face Normals）和边的方向向量（Edge Directions）。

using Unity.Mathematics; using Unity.Collections; // 使用Burst兼容的类型定义凸体数据结构 public struct ConvexHullData { public NativeArray<float3> vertices; // 顶点列表（局部坐标） public NativeArray<float3> faceNormals; // 每个面的单位法线（局部坐标） public NativeArray<float3> edgeDirections; // 归一化的边方向向量 public float3 worldPosition; public quaternion worldRotation; public float3 worldScale; }

设计要点：

使用Unity.Mathematics中的float3,quaternion代替传统的Vector3,Quaternion。这些类型是值类型，且被Burst完全支持，能产生更优化的代码。
使用NativeArray<T>在非托管内存中存储数据。这是与Burst Job进行安全、高效数据交互的标准方式，避免了托管堆的分配和GC。
存储世界变换信息，用于在检测时将局部坐标的顶点和法线变换到世界空间。SAT检测通常在统一的世界空间或其中一个物体的局部空间中进行。

3.2 SAT算法的Burst Job化设计

我们将核心的SAT检测逻辑封装在一个Burst Job中。Job系统允许我们以多线程安全的方式调度工作。

using Unity.Burst; using Unity.Jobs; using Unity.Collections; [BurstCompile] // 关键特性，指示Burst编译此Job public struct SATCollisionCheckJob : IJob { // 输入：两个凸体的数据 public ConvexHullData hullA; public ConvexHullData hullB; // 输出：碰撞结果 public NativeReference<bool> isColliding; [WriteOnly] public NativeReference<float3> collisionNormal; // 可选的碰撞法线 [WriteOnly] public NativeReference<float> penetrationDepth; // 可选的穿透深度 public void Execute() { bool colliding = true; float3 minAxis = float3.zero; float minOverlap = float.MaxValue; // 1. 测试物体A的所有面法线作为分离轴 for (int i = 0; i < hullA.faceNormals.Length; i++) { float3 axis = math.mul(hullA.worldRotation, hullA.faceNormals[i]); // 变换到世界空间 if (!CheckOverlapOnAxis(axis, hullA, hullB, out float overlap)) { isColliding.Value = false; return; // Early-out: 找到分离轴 } if (overlap < minOverlap) { minOverlap = overlap; minAxis = axis; } } // 2. 测试物体B的所有面法线作为分离轴 for (int i = 0; i < hullB.faceNormals.Length; i++) { float3 axis = math.mul(hullB.worldRotation, hullB.faceNormals[i]); if (!CheckOverlapOnAxis(axis, hullA, hullB, out float overlap)) { isColliding.Value = false; return; } if (overlap < minOverlap) { minOverlap = overlap; minAxis = axis; } } // 3. 测试所有边对的叉积方向作为分离轴 (AxB) for (int i = 0; i < hullA.edgeDirections.Length; i++) { float3 edgeA = math.mul(hullA.worldRotation, hullA.edgeDirections[i]); for (int j = 0; j < hullB.edgeDirections.Length; j++) { float3 edgeB = math.mul(hullB.worldRotation, hullB.edgeDirections[j]); float3 axis = math.normalize(math.cross(edgeA, edgeB)); // 注意：叉积可能得到零向量（边平行），需要跳过 if (math.lengthsq(axis) < 0.0001f) continue; if (!CheckOverlapOnAxis(axis, hullA, hullB, out float overlap)) { isColliding.Value = false; return; } if (overlap < minOverlap) { minOverlap = overlap; minAxis = axis; } } } // 如果所有轴都未分离，则发生碰撞 isColliding.Value = true; collisionNormal.Value = minAxis; penetrationDepth.Value = minOverlap; } // 核心函数：在给定轴上计算两个凸体的投影是否重叠 private bool CheckOverlapOnAxis(float3 axis, in ConvexHullData hullA, in ConvexHullData hullB, out float overlap) { // 投影物体A的所有顶点 ProjectVertices(axis, hullA, out float minA, out float maxA); // 投影物体B的所有顶点 ProjectVertices(axis, hullB, out float minB, out float maxB); // 检查投影区间是否重叠 if (maxA < minB || maxB < minA) { overlap = 0; return false; // 区间分离，此轴为分离轴 } // 计算重叠深度 overlap = math.min(maxA, maxB) - math.max(minA, minB); return true; } private void ProjectVertices(float3 axis, in ConvexHullData hull, out float min, out float max) { min = float.MaxValue; max = float.MinValue; for (int i = 0; i < hull.vertices.Length; i++) { // 将顶点变换到世界空间 float3 worldVertex = hull.worldPosition + math.mul(hull.worldRotation, hull.vertices[i] * hull.worldScale); // 计算在轴上的投影标量值 float projection = math.dot(worldVertex, axis); min = math.min(min, projection); max = math.max(max, projection); } } }

关键设计解析：

[BurstCompile]特性：这是启用Burst编译的关键。确保Job内使用的所有类型和方法都是Burst兼容的。
IJob接口：这是一个在主线程调度、也在主线程完成的Job。对于单次碰撞检测，这足够了。如果需要批量检测，可以考虑IJobParallelFor。
NativeReference<T>用于输出标量结果。它是线程安全的引用类型，适用于Job输出。
Early-out优化：在循环中一旦发现分离轴，立即返回false，避免不必要的计算。
向量运算：全程使用math.dot,math.cross,math.normalize等数学函数，它们会被Burst高效编译。

4. 完整实现流程与集成到Unity

有了核心算法Job，我们需要在Unity的MonoBehaviour生命周期中搭建一套管理系统，用于创建凸体数据、调度Job并处理结果。

4.1 凸体数据的构建与缓存

我们不可能每帧都从Mesh重新计算凸体数据。通常，在Awake或Start时，根据MeshFilter或自定义形状，预计算并缓存ConvexHullData所需的信息。

using UnityEngine; using Unity.Collections; using Unity.Mathematics; public class SATConvexCollider : MonoBehaviour { private ConvexHullData _hullData; private bool _isInitialized = false; // 可以从MeshFilter获取，或手动定义顶点 public Vector3[] localVertices; void Start() { InitializeHullData(); } void InitializeHullData() { // 1. 计算凸包（如果顶点不是凸包顶点）。这里假设localVertices已经是凸包顶点。 // 2. 计算面法线。对于简单形状如立方体、球体（近似），可以手动定义。 // 3. 计算边方向。 // 示例：为一个立方体手动构建数据（简化版，实际应从Mesh计算） int vertexCount = localVertices.Length; using (var vertices = new NativeArray<float3>(vertexCount, Allocator.Temp)) using (var normals = new NativeArray<float3>(6, Allocator.Temp)) // 立方体6个面 using (var edges = new NativeArray<float3>(12, Allocator.Temp)) // 立方体12条边 { // 填充vertices... // 计算面法线（例如，(1,0,0), (-1,0,0)...） // 计算边方向（顶点相减并归一化） // 持久化到NativeArray，使用Allocator.Persistent _hullData.vertices = new NativeArray<float3>(vertices, Allocator.Persistent); _hullData.faceNormals = new NativeArray<float3>(normals, Allocator.Persistent); _hullData.edgeDirections = new NativeArray<float3>(edges, Allocator.Persistent); } _hullData.worldPosition = float3.zero; _hullData.worldRotation = quaternion.identity; _hullData.worldScale = new float3(transform.lossyScale); _isInitialized = true; } void OnDestroy() { // 必须手动释放NativeArray，避免内存泄漏 if (_hullData.vertices.IsCreated) _hullData.vertices.Dispose(); if (_hullData.faceNormals.IsCreated) _hullData.faceNormals.Dispose(); if (_hullData.edgeDirections.IsCreated) _hullData.edgeDirections.Dispose(); } // 每帧更新世界变换 void Update() { if (!_isInitialized) return; _hullData.worldPosition = transform.position; _hullData.worldRotation = transform.rotation; _hullData.worldScale = transform.lossyScale; } public ConvexHullData GetHullData() => _hullData; }

注意：从任意Mesh生成凸包和计算面法线、边方向是一个复杂的几何处理过程。在实际项目中，你可能会在编辑器模式下预计算并序列化这些数据，或者在运行时使用专门的几何库（如UnityEngine.Mesh的API结合算法）来计算。对于复杂模型，网络热词中提到的“凸包碰撞检测逻辑”可能需要你先进行凸包分解。

4.2 碰撞检测管理器与Job调度

我们需要一个管理器来组织所有的SATConvexCollider，并在每帧执行必要的碰撞检测对。

using System.Collections.Generic; using UnityEngine; using Unity.Jobs; using Unity.Collections; using Unity.Burst; public class SATCollisionManager : MonoBehaviour { public static SATCollisionManager Instance; private List<SATConvexCollider> _colliders = new List<SATConvexCollider>(); void Awake() => Instance = this; void Update() { // 简单的两两检测，实际应用会使用空间划分（如网格、四叉树/八叉树）来减少检测对 for (int i = 0; i < _colliders.Count; i++) { for (int j = i + 1; j < _colliders.Count; j++) { CheckCollisionPair(_colliders[i], _colliders[j]); } } } void CheckCollisionPair(SATConvexCollider colliderA, SATConvexCollider colliderB) { var hullA = colliderA.GetHullData(); var hullB = colliderB.GetHullData(); // 准备Job使用的Native容器 var isCollidingRef = new NativeReference<bool>(Allocator.TempJob); var collisionNormalRef = new NativeReference<float3>(Allocator.TempJob); var penetrationDepthRef = new NativeReference<float>(Allocator.TempJob); // 创建并调度Job var job = new SATCollisionCheckJob { hullA = hullA, hullB = hullB, isColliding = isCollidingRef, collisionNormal = collisionNormalRef, penetrationDepth = penetrationDepthRef }; // 立即在主线程执行Job（对于简单检测够用，复杂情况可Schedule） job.Run(); // 获取结果 if (isCollidingRef.Value) { Debug.Log($"Collision detected between {colliderA.name} and {colliderB.name}"); Debug.Log($"Collision Normal: {collisionNormalRef.Value}, Depth: {penetrationDepthRef.Value}"); // 触发碰撞事件，或解析碰撞信息进行物理响应 // 例如，可以调用 colliderA.OnSATCollision(colliderB, collisionNormalRef.Value, ...); } // 释放临时Native容器 isCollidingRef.Dispose(); collisionNormalRef.Dispose(); penetrationDepthRef.Dispose(); } public void Register(SATConvexCollider collider) => _colliders.Add(collider); public void Unregister(SATConvexCollider collider) => _colliders.Remove(collider); }

实现要点与陷阱：

性能瓶颈转移：两两检测的复杂度是O(N²)。当物体数量超过几百时，即使单个检测再快，总次数也会成为瓶颈。必须结合空间加速结构，如网格（Grid）、四叉树（2D）或八叉树（3D）、BVH（包围体层次结构）等。这又是一个大的优化主题，其核心是快速筛选出可能发生碰撞的物体对（Broad Phase），再交给SAT进行精确检测（Narrow Phase）。
Job的调度模式：这里使用了Job.Run()在主线程同步执行。它的好处是简单，无需处理依赖关系。但如果检测对非常多，可以考虑使用JobHandle Schedule()进行异步调度，并配合JobHandle.Complete()在需要结果时等待。对于超大规模检测，甚至可以使用IJobParallelFor来并行处理多个检测对。
内存管理：NativeReference和NativeArray必须被正确释放（Dispose）。这里使用了Allocator.TempJob，它的生命周期仅限于当前Job链，在Job完成后可以安全地由系统回收，但显式调用Dispose是好习惯。对于持久化数据（如_hullData中的数组），必须使用Allocator.Persistent并在物体销毁时手动释放。

4.3 碰撞响应与物理集成

检测到碰撞后，通常需要产生响应。简单的响应可以是直接弹开（利用碰撞法线），复杂的则需要模拟冲量、摩擦等。

// 在SATConvexCollider组件上添加响应方法 public class SATConvexCollider : MonoBehaviour { // ... 之前的数据和初始化代码 ... public float bounciness = 0.5f; // 弹性系数 public void OnSATCollision(SATConvexCollider other, float3 collisionNormal, float penetrationDepth) { // 最简单的响应：基于穿透深度的分离 float3 separationVector = collisionNormal * penetrationDepth; // 假设当前物体是动态的，另一个是静态的 transform.position += new Vector3(separationVector.x, separationVector.y, separationVector.z) * 0.5f; // 简单的速度反射（模拟弹性碰撞） Rigidbody rb = GetComponent<Rigidbody>(); if (rb != null) { Vector3 incidentVelocity = rb.velocity; Vector3 reflectedVelocity = Vector3.Reflect(incidentVelocity, new Vector3(collisionNormal.x, collisionNormal.y, collisionNormal.z)); rb.velocity = reflectedVelocity * bounciness; } // 触发事件 // onCollisionEvent?.Invoke(other); } }

注意：这只是一个极其简化的响应模型。真实的物理响应非常复杂，涉及质量、动量、角动量、摩擦系数等。你可以根据游戏需求实现简化的响应，或者将碰撞信息（法线、深度、接触点）传递给一个更复杂的自定义物理求解器。如果你的游戏需要“Unity 实现完全弹性碰撞”，那么你需要精确计算碰撞前后的动量和动能。

5. 高级优化、调试与实战心得

将基础系统跑起来只是第一步，让它稳定、高效、易调试才是挑战的开始。

5.1 性能深度优化技巧

空间划分（Broad Phase）：这是应对大量物体的不二法门。根据游戏类型选择：
- 均匀网格：适用于物体分布相对均匀的场景，如弹幕游戏。将空间划分为固定大小的格子，每个物体根据位置存入对应格子的列表。检测时，只需检查物体所在格子及相邻格子的物体。
- 动态AABB树：适用于物体动态添加移除、大小不一的情况。Unity的PhysX内部就使用了BVH。你可以使用第三方库或自己实现一个简单的动态包围盒树来管理你的SATConvexCollider。
- 四叉树/八叉树：适用于空间物体分布不均匀的场景，能动态调整空间划分的粒度。
SAT算法本身的优化：
- 轴缓存与预计算：将世界空间的分离轴预计算并缓存起来，如果物体在本帧没有旋转，就可以复用上一帧的轴，避免重复的矩阵乘法。
- 投影区间缓存：对于静态或低速物体，可以缓存其顶点在常用轴上的投影极值。
- 使用Unity.Mathematics的SIMD类型：考虑使用float4同时处理多个数据，但需要精心设计数据布局（SoA vs AoS）。Burst对float4、float4x4等类型的向量化支持更好。
Burst Job的进阶用法：
- 使用IJobParallelFor进行批量检测：将所有需要检测的物体对收集到一个NativeArray中，然后使用并行Job一次性处理。这能充分利用多核CPU。
- 使用[NativeDisableContainerSafetyRestriction]：在确保安全的前提下，可以禁用某些安全检查以获得微小的性能提升，但必须非常小心，否则会导致难以调试的内存错误。
- Profile with Burst Inspector：使用[BurstCompile(CompileSynchronously = true)]并在编辑器菜单Jobs -> Burst -> Open Inspector中查看生成的汇编代码，分析优化瓶颈。

5.2 可视化调试：让碰撞“看得见”

调试物理代码，尤其是自定义的物理代码，可视化至关重要。

void OnDrawGizmosSelected() { if (!_isInitialized) return; // 1. 绘制凸包线框 Gizmos.color = Color.cyan; for (int i = 0; i < _hullData.vertices.Length; i++) { float3 vertWorld = _hullData.worldPosition + math.mul(_hullData.worldRotation, _hullData.vertices[i] * _hullData.worldScale); for (int j = i + 1; j < _hullData.vertices.Length; j++) { // 这里需要根据你的凸包顶点连接关系来画线，简化处理：绘制所有顶点连线（凸包应只绘制边） float3 vertWorldJ = _hullData.worldPosition + math.mul(_hullData.worldRotation, _hullData.vertices[j] * _hullData.worldScale); Gizmos.DrawLine(vertWorld, vertWorldJ); } } // 2. 绘制面法线 Gizmos.color = Color.green; for (int i = 0; i < _hullData.faceNormals.Length; i++) { float3 faceCenter = CalculateFaceCenter(i); // 需要实现此函数计算面中心点 float3 normalWorld = math.mul(_hullData.worldRotation, _hullData.faceNormals[i]); Gizmos.DrawRay(faceCenter, normalWorld); } }

你还可以在碰撞发生时，用Debug.DrawLine或Gizmos.DrawWireSphere在碰撞点或沿着碰撞法线绘制标记，这能直观地确认碰撞检测和法线计算是否正确。

5.3 常见问题与排查实录

在实际集成中，你几乎一定会遇到下面这些问题：

问题1：检测结果不稳定，物体轻微穿插或抖动。

原因：浮点数精度误差。在判断投影是否分离时，使用了maxA < minB。当两个投影区间刚好接触时，浮点误差可能导致一帧判断为碰撞，下一帧判断为分离。

解决：引入一个微小的容差（epsilon）。

float epsilon = 0.001f; if (maxA < minB - epsilon || maxB < minA - epsilon) { // 分离 }

问题2：Burst Job编译失败，报错“XXX不是blittable类型”或“调用了非Burst兼容的函数”。

原因：Burst对代码有严格限制。不能使用托管类型（如class）、字符串操作、foreach循环（对NativeArray有特殊版本）、反射等。
解决：
- 确保Job内所有字段和局部变量都是Burst兼容的数值类型或结构体（如float3,quaternion,NativeArray<T>）。
- 只调用Unity.Mathematics中的math函数或自己编写的、同样标记了[BurstCompile]的函数。
- 将foreach改为普通的for循环。

问题3：运行时报错“Attempting to Dispose a NativeArray that is not allocated”。

原因：NativeArray的生命周期管理不当。可能尝试释放一个未初始化的数组，或者一个已经释放过的数组。
解决：
- 在Dispose()前，始终检查IsCreated属性。
- 明确所有权。哪个脚本创建的数组，就由哪个脚本负责释放。避免多个地方释放同一个数组。
- 对于在Job中创建的临时容器，使用Allocator.TempJob，并在Job完成后尽快释放（或依赖Job依赖系统自动释放）。

问题4：性能提升不明显，甚至更慢了。

原因：
- 数据准备开销大：每帧都在构建NativeArray或计算凸体数据。解决方案是缓存和复用。
- Broad Phase缺失：仍然在进行O(N²)的全量检测。必须实现空间划分。
- Job开销本身：对于极少量（如几个）的检测对，调度Job的开销可能超过其计算收益。对于简单场景，直接在主线程用Burst编译后的函数（通过[BurstCompile]标记一个静态函数）计算可能更合适。
- 频繁的Native容器分配：在Update中频繁new NativeReference/Array会导致内存分配。使用对象池来复用这些容器。

问题5：旋转后的碰撞检测不正确。

原因：最可能的原因是法线和边方向向量没有随物体旋转正确变换。记住，SAT要求所有计算在同一个坐标系（通常是世界空间）中进行。你缓存的是局部空间的法线，每帧都需要用物体的旋转quaternion去变换它。
解决：确保在Job的Execute方法中，或是在将数据传入Job前，正确计算了世界空间的轴：math.mul(worldRotation, localAxis)。

6. 扩展方向与项目集成思考

这套自定义碰撞系统并非要完全取代Unity的PhysX，而是在特定场景下作为高性能补充。在实际项目中，你可以考虑以下集成模式：

混合模式：对于主要的、复杂的角色和场景，仍然使用标准的Rigidbody和Collider。对于大量同质的、需要高性能检测的物体（如子弹、特效粒子、掉落物），使用这套SAT+Burst系统。两者可以通过层（Layer）或自定义逻辑来区分。
服务器端物理：对于需要服务器权威验证的游戏，你可以在服务器端用C#实现一套同样的逻辑，确保客户端和服务器端的物理判定一致，避免外挂。Burst编译器同样可以在独立的.NET环境中使用。
与Unity ECS深度集成：这是最理想的架构。将凸体数据（顶点、法线）存储在IComponentData中，将SAT检测逻辑放在System中，并使用Entities.ForEach与Burst Job结合。这能实现极致的数据局部性和并行效率，是应对超大规模实体碰撞的终极方案。这也是网络热词中“unity ecs”所代表的方向。
生成碰撞信息供PhysX使用：你可以用SAT进行精确的碰撞检测，然后将碰撞点、法线等信息，通过Physics.ClosestPoint或自定义的Contact Point结构，反馈给Unity的物理引擎来产生标准的碰撞消息和力反馈，从而复用PhysX的求解器。