563 lines
22 KiB
C#
563 lines
22 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
using WaveHarmonic.Crest;
|
||
|
||
namespace NBF
|
||
{
|
||
/// <summary>
|
||
/// 小型浮漂/小物体：基于 Crest 的浮力（自动从多个 CapsuleCollider 计算尺寸与探针）
|
||
/// - 自动收集自身与子物体上的 CapsuleCollider（可多个）
|
||
/// - 计算整体长轴、长度、最大直径、底部高度
|
||
/// - 自动设置 Crest 查询尺度 _ObjectWidth（与直径同量级）
|
||
/// - 自动生成 5 个探针：底部四周 + 底部中心（更稳）
|
||
/// - 浮力：弹簧(k) + 阻尼(c)，ForceMode.Force（质量参与）
|
||
/// </summary>
|
||
public sealed class BobberFloating : MonoBehaviour
|
||
{
|
||
[Header("Crest")]
|
||
public WaterRenderer _water;
|
||
|
||
[SerializeField] Rigidbody _RigidBody;
|
||
|
||
[Tooltip("要瞄准哪一层水的碰撞层。")]
|
||
[SerializeField] CollisionLayer _Layer = CollisionLayer.AfterAnimatedWaves;
|
||
|
||
// -----------------------------
|
||
// 自动从 CapsuleCollider 计算
|
||
// -----------------------------
|
||
[Header("Auto from CapsuleColliders")]
|
||
[Tooltip("自动扫描自己与子物体的 CapsuleCollider，并计算尺寸/探针/采样尺度。")]
|
||
[SerializeField] bool _AutoFromCapsules = true;
|
||
|
||
[Tooltip("仅使用 enabled 的 CapsuleCollider。")]
|
||
[SerializeField] bool _OnlyEnabledCapsules = true;
|
||
|
||
[Tooltip("运行时也会每隔一定时间重建（应对浮漂缩放/更换碰撞体）。0 表示仅 Start/OnValidate 时重建。")]
|
||
[SerializeField] float _RuntimeRebuildInterval = 0f;
|
||
|
||
[Tooltip("给估算出来的直径乘一个系数，用于更稳的 Crest 查询与阻尼。通常 1.0~2.0。")]
|
||
[Range(0.5f, 3f)]
|
||
[SerializeField] float _WidthMultiplier = 1.2f;
|
||
|
||
[Tooltip("探针半径比例（相对估算半径）。越大越“撑开”，越抗翻滚，但也更容易被浪抬。建议 0.6~0.9")]
|
||
[Range(0.1f, 1.2f)]
|
||
[SerializeField] float _ProbeRadiusRatio = 0.75f;
|
||
|
||
[Tooltip("探针在底部之上的抬高（米）。用于避免探针刚好在最底点导致抖动。建议：半径的 5%~20%。")]
|
||
[SerializeField] float _ProbeLiftMeters = 0.0f;
|
||
|
||
[Tooltip("探针权重分配：四周总权重（其余给中心）。建议 0.6~0.9")]
|
||
[Range(0f, 1f)]
|
||
[SerializeField] float _RingWeight = 0.75f;
|
||
|
||
// -----------------------------
|
||
// 物理参数（吃水可控）
|
||
// -----------------------------
|
||
[Header("Buoyancy (controllable submergence)")]
|
||
[Tooltip("目标吃水比例：以“直径”为尺度。\n例：0.30 表示目标吃水深度约 = 直径*0.30。\n对小浮漂非常好调：想更浮（露更多）-> 降低；想更沉 -> 提高。")]
|
||
[Range(0.05f, 1.2f)]
|
||
[SerializeField] float _TargetSubmergenceRatio = 0.30f;
|
||
|
||
[Tooltip("浮力阻尼比（0~2 常用）。越大越不抖，但会显得黏。推荐 0.7~1.2")]
|
||
[Range(0f, 2f)]
|
||
[SerializeField] float _DampingRatio = 0.95f;
|
||
|
||
[Tooltip("最大总浮力（N）保护。若为 Infinity 则不限制。")]
|
||
[SerializeField] float _MaximumBuoyancyForce = 50f;
|
||
|
||
[Tooltip("吃水偏移（米）。用于校准 pivot/碰撞体中心误差。\n>0 更容易浮起（等效更浅），<0 更沉。")]
|
||
[SerializeField] float _SubmergenceOffset = 0f;
|
||
|
||
[Header("Water drag (relative to water surface velocity/flow)")]
|
||
[Tooltip("相对水的线性阻力（N per m/s）。小浮漂建议从 (0.2, 0.6, 0.2) 起。")]
|
||
[SerializeField] Vector3 _Drag = new(0.2f, 0.6f, 0.2f);
|
||
|
||
[Tooltip("角阻力（N*m per rad/s）。小浮漂建议 0.01~0.05。")]
|
||
[SerializeField] float _AngularDrag = 0.03f;
|
||
|
||
[Header("Optional downhill acceleration")]
|
||
[Range(0, 1)]
|
||
[SerializeField] float _AccelerateDownhill = 0f;
|
||
|
||
[Header("Force application height offset")]
|
||
[SerializeField] float _ForceHeightOffset = 0f;
|
||
|
||
// -----------------------------
|
||
// 自动生成的“几何结果”
|
||
// -----------------------------
|
||
[Header("Computed (read-only)")]
|
||
[SerializeField] float _ComputedLength = 0.1f;
|
||
[SerializeField] float _ComputedDiameter = 0.04f;
|
||
[SerializeField] Vector3 _ComputedAxisLocal = Vector3.up; // 刚体局部坐标中的长轴（单位向量）
|
||
[SerializeField] float _ComputedBottomLocalY = -0.02f; // 刚体局部坐标中“整体最低点”的 y（沿长轴方向投影不是y；这里是按 rb local Y，仅用于Debug显示）
|
||
|
||
[Header("Wave response / query scale")]
|
||
[Tooltip("用于 Crest 查询的物体宽度（米）。会自动从 Capsule 直径推算。")]
|
||
[SerializeField] float _ObjectWidth = 0.04f;
|
||
|
||
// -----------------------------
|
||
// Debug
|
||
// -----------------------------
|
||
[Space(10)]
|
||
[SerializeField] DebugFields _Debug = new();
|
||
|
||
[Serializable]
|
||
sealed class DebugFields
|
||
{
|
||
[SerializeField] internal bool _DrawProbes = false;
|
||
[SerializeField] internal bool _DrawForces = false;
|
||
}
|
||
|
||
/// <summary>是否有任意探针入水</summary>
|
||
public bool InWater { get; private set; }
|
||
|
||
// 探针（刚体局部空间，相对 worldCenterOfMass）
|
||
struct Probe
|
||
{
|
||
public Vector3 localOffsetFromCOM;
|
||
public float weight;
|
||
}
|
||
|
||
Probe[] _Probes = Array.Empty<Probe>();
|
||
|
||
readonly SampleFlowHelper _SampleFlowHelper = new();
|
||
|
||
Vector3[] _QueryPoints;
|
||
Vector3[] _QueryResultDisplacements;
|
||
Vector3[] _QueryResultVelocities;
|
||
Vector3[] _QueryResultNormal;
|
||
|
||
float _NextRebuildTime = 0f;
|
||
|
||
void Reset()
|
||
{
|
||
if (_RigidBody == null) TryGetComponent(out _RigidBody);
|
||
}
|
||
|
||
void OnValidate()
|
||
{
|
||
_ObjectWidth = Mathf.Max(0.001f, _ObjectWidth);
|
||
_RuntimeRebuildInterval = Mathf.Max(0f, _RuntimeRebuildInterval);
|
||
_ProbeLiftMeters = Mathf.Max(0f, _ProbeLiftMeters);
|
||
|
||
if (!Application.isPlaying)
|
||
{
|
||
if (_AutoFromCapsules)
|
||
{
|
||
TryRebuildFromCapsules(editor: true);
|
||
}
|
||
AllocateQueryArrays();
|
||
}
|
||
}
|
||
|
||
void Start()
|
||
{
|
||
if (_RigidBody == null) TryGetComponent(out _RigidBody);
|
||
|
||
if (_AutoFromCapsules)
|
||
{
|
||
TryRebuildFromCapsules(editor: false);
|
||
}
|
||
|
||
AllocateQueryArrays();
|
||
}
|
||
|
||
void FixedUpdate()
|
||
{
|
||
if (_water == null || _RigidBody == null) return;
|
||
|
||
if (_AutoFromCapsules && _RuntimeRebuildInterval > 0f && Time.time >= _NextRebuildTime)
|
||
{
|
||
_NextRebuildTime = Time.time + _RuntimeRebuildInterval;
|
||
TryRebuildFromCapsules(editor: false);
|
||
AllocateQueryArrays();
|
||
}
|
||
|
||
if (_Probes == null || _Probes.Length == 0) return;
|
||
|
||
// Crest provider
|
||
var collisions = _water.AnimatedWavesLod.Provider;
|
||
|
||
int probeCount = _Probes.Length;
|
||
int centerIndex = probeCount; // 最后一个点用于中心采样（表面速度/法线）
|
||
|
||
Vector3 comWorld = _RigidBody.worldCenterOfMass;
|
||
|
||
// Build query points
|
||
for (int i = 0; i < probeCount; i++)
|
||
{
|
||
_QueryPoints[i] = comWorld + transform.TransformVector(_Probes[i].localOffsetFromCOM);
|
||
}
|
||
_QueryPoints[centerIndex] = comWorld;
|
||
|
||
// Query waves
|
||
collisions.Query(
|
||
GetHashCode(),
|
||
_ObjectWidth,
|
||
_QueryPoints,
|
||
_QueryResultDisplacements,
|
||
_QueryResultNormal,
|
||
_QueryResultVelocities,
|
||
_Layer
|
||
);
|
||
|
||
// Surface velocity + flow
|
||
Vector3 surfaceVelocity = _QueryResultVelocities[centerIndex];
|
||
_SampleFlowHelper.Sample(transform.position, out var surfaceFlow, minimumLength: _ObjectWidth);
|
||
surfaceVelocity += new Vector3(surfaceFlow.x, 0f, surfaceFlow.y);
|
||
|
||
// Compute buoyancy coefficients
|
||
float g = Mathf.Abs(Physics.gravity.y);
|
||
|
||
// 目标吃水深度（米）：按直径比例
|
||
float targetSubmergence = Mathf.Max(0.0005f, _ComputedDiameter * _TargetSubmergenceRatio);
|
||
|
||
// 总弹簧系数：k ≈ m*g / targetSubmergence
|
||
float kTotal = (_RigidBody.mass * g) / targetSubmergence;
|
||
|
||
// 总阻尼：c = 2*sqrt(k*m)*dampingRatio
|
||
float cTotal = 2f * Mathf.Sqrt(Mathf.Max(0.0001f, kTotal * _RigidBody.mass)) * _DampingRatio;
|
||
|
||
InWater = false;
|
||
float totalBuoyMag = 0f;
|
||
|
||
// Apply distributed buoyancy
|
||
for (int i = 0; i < probeCount; i++)
|
||
{
|
||
Vector3 p = _QueryPoints[i];
|
||
float waterHeight = _QueryResultDisplacements[i].y + _water.SeaLevel;
|
||
|
||
// depth: positive means submerged
|
||
float depth = (waterHeight - p.y) + _SubmergenceOffset;
|
||
if (depth <= 0f) continue;
|
||
|
||
InWater = true;
|
||
|
||
float w = Mathf.Max(0.0001f, _Probes[i].weight);
|
||
|
||
// spring
|
||
float FiSpring = (kTotal * w) * depth;
|
||
|
||
// damping (vertical relative velocity)
|
||
Vector3 pointVel = _RigidBody.GetPointVelocity(p);
|
||
float vRel = Vector3.Dot(pointVel - surfaceVelocity, Vector3.up);
|
||
float FiDamp = -(cTotal * w) * vRel;
|
||
|
||
float Fi = FiSpring + FiDamp;
|
||
if (Fi < 0f) Fi = 0f;
|
||
|
||
totalBuoyMag += Fi;
|
||
|
||
Vector3 force = Fi * Vector3.up;
|
||
_RigidBody.AddForceAtPosition(force, p, ForceMode.Force);
|
||
|
||
if (_Debug._DrawForces)
|
||
{
|
||
Debug.DrawLine(p, p + force * 0.02f, Color.cyan);
|
||
}
|
||
}
|
||
|
||
if (!InWater) return;
|
||
|
||
// Clamp buoyancy (simple safety)
|
||
if (_MaximumBuoyancyForce < Mathf.Infinity && totalBuoyMag > _MaximumBuoyancyForce)
|
||
{
|
||
float excess = totalBuoyMag - _MaximumBuoyancyForce;
|
||
_RigidBody.AddForce(-excess * Vector3.up, ForceMode.Force);
|
||
}
|
||
|
||
// Optional downhill acceleration (usually 0 for bobber)
|
||
if (_AccelerateDownhill > 0f)
|
||
{
|
||
Vector3 normal = _QueryResultNormal[centerIndex];
|
||
_RigidBody.AddForce(_AccelerateDownhill * g * new Vector3(normal.x, 0f, normal.z), ForceMode.Force);
|
||
}
|
||
|
||
// Angular drag
|
||
if (_AngularDrag > 0f)
|
||
{
|
||
_RigidBody.AddTorque(-_AngularDrag * _RigidBody.angularVelocity, ForceMode.Force);
|
||
}
|
||
|
||
// Linear drag relative to water
|
||
if (_Drag != Vector3.zero)
|
||
{
|
||
Vector3 velocityRelativeToWater = _RigidBody.linearVelocity - surfaceVelocity;
|
||
Vector3 forcePosition = _RigidBody.worldCenterOfMass + _ForceHeightOffset * Vector3.up;
|
||
|
||
_RigidBody.AddForceAtPosition(
|
||
_Drag.x * Vector3.Dot(transform.right, -velocityRelativeToWater) * transform.right,
|
||
forcePosition,
|
||
ForceMode.Force);
|
||
|
||
_RigidBody.AddForceAtPosition(
|
||
_Drag.y * Vector3.Dot(Vector3.up, -velocityRelativeToWater) * Vector3.up,
|
||
forcePosition,
|
||
ForceMode.Force);
|
||
|
||
_RigidBody.AddForceAtPosition(
|
||
_Drag.z * Vector3.Dot(transform.forward, -velocityRelativeToWater) * transform.forward,
|
||
forcePosition,
|
||
ForceMode.Force);
|
||
}
|
||
|
||
if (_Debug._DrawProbes)
|
||
{
|
||
for (int i = 0; i < probeCount; i++)
|
||
{
|
||
Debug.DrawLine(_QueryPoints[i], _QueryPoints[i] + Vector3.up * 0.05f, Color.yellow);
|
||
}
|
||
}
|
||
}
|
||
|
||
void AllocateQueryArrays()
|
||
{
|
||
int probeCount = _Probes?.Length ?? 0;
|
||
int n = probeCount + 1; // +1 center sample
|
||
if (n <= 1) n = 2;
|
||
|
||
if (_QueryPoints != null && _QueryPoints.Length == n) return;
|
||
|
||
_QueryPoints = new Vector3[n];
|
||
_QueryResultDisplacements = new Vector3[n];
|
||
_QueryResultVelocities = new Vector3[n];
|
||
_QueryResultNormal = new Vector3[n];
|
||
}
|
||
|
||
/// <summary>
|
||
/// 公开按钮：手动重建（你也可以在 Inspector 右键脚本 -> Reset，然后 Play）
|
||
/// </summary>
|
||
[ContextMenu("Rebuild From CapsuleColliders")]
|
||
public void RebuildFromCapsules()
|
||
{
|
||
TryRebuildFromCapsules(editor: Application.isEditor && !Application.isPlaying);
|
||
AllocateQueryArrays();
|
||
}
|
||
|
||
bool TryRebuildFromCapsules(bool editor)
|
||
{
|
||
var capsules = GetComponentsInChildren<CapsuleCollider>(includeInactive: true);
|
||
if (capsules == null || capsules.Length == 0)
|
||
{
|
||
// 没胶囊就不改
|
||
return false;
|
||
}
|
||
|
||
// 收集点（在刚体局部空间）
|
||
List<Vector3> ptsLocal = new List<Vector3>(capsules.Length * 8);
|
||
|
||
// 同时估算“长轴”：取所有胶囊在 rb local 的端点云，计算 AABB 最大跨度轴
|
||
// 这比“看某个 Capsule.direction”更鲁棒（因为你说可能多个、分布复杂）
|
||
foreach (var cap in capsules)
|
||
{
|
||
if (cap == null) continue;
|
||
if (_OnlyEnabledCapsules && !cap.enabled) continue;
|
||
|
||
AddCapsuleSamplePointsInRbLocal(cap, ptsLocal);
|
||
}
|
||
|
||
if (ptsLocal.Count < 2) return false;
|
||
|
||
// AABB in rb local
|
||
Vector3 min = ptsLocal[0];
|
||
Vector3 max = ptsLocal[0];
|
||
for (int i = 1; i < ptsLocal.Count; i++)
|
||
{
|
||
min = Vector3.Min(min, ptsLocal[i]);
|
||
max = Vector3.Max(max, ptsLocal[i]);
|
||
}
|
||
|
||
Vector3 size = max - min;
|
||
|
||
// 估算长轴：取跨度最大的轴
|
||
// 注意：这是 rb local 坐标的轴（x/y/z），足够用于“尺寸”和“探针布局”
|
||
int axis = 0;
|
||
float spanX = size.x;
|
||
float spanY = size.y;
|
||
float spanZ = size.z;
|
||
if (spanY >= spanX && spanY >= spanZ) axis = 1;
|
||
else if (spanZ >= spanX && spanZ >= spanY) axis = 2;
|
||
else axis = 0;
|
||
|
||
Vector3 axisLocal = axis == 0 ? Vector3.right : axis == 1 ? Vector3.up : Vector3.forward;
|
||
|
||
// length along that axis
|
||
float length = axis == 0 ? spanX : axis == 1 ? spanY : spanZ;
|
||
|
||
// diameter：取另外两轴的最大跨度（更保守）
|
||
float dia;
|
||
if (axis == 0) dia = Mathf.Max(spanY, spanZ);
|
||
else if (axis == 1) dia = Mathf.Max(spanX, spanZ);
|
||
else dia = Mathf.Max(spanX, spanY);
|
||
|
||
dia = Mathf.Max(0.001f, dia);
|
||
|
||
_ComputedLength = length;
|
||
_ComputedDiameter = dia;
|
||
_ComputedAxisLocal = axisLocal;
|
||
|
||
// Crest 查询尺度：直径同量级 * multiplier，且给下限
|
||
_ObjectWidth = Mathf.Max(0.002f, _ComputedDiameter * _WidthMultiplier);
|
||
|
||
// 估算“底部位置”（用于探针 y）
|
||
// 我们按“长轴”方向找最小投影的点作为底部
|
||
float minProj = float.PositiveInfinity;
|
||
Vector3 bottom = ptsLocal[0];
|
||
for (int i = 0; i < ptsLocal.Count; i++)
|
||
{
|
||
float proj = Vector3.Dot(ptsLocal[i], axisLocal);
|
||
if (proj < minProj)
|
||
{
|
||
minProj = proj;
|
||
bottom = ptsLocal[i];
|
||
}
|
||
}
|
||
|
||
// 这个值只是给你在 Inspector 看一眼，不参与计算
|
||
_ComputedBottomLocalY = bottom.y;
|
||
|
||
// 生成探针：以“底部附近”一圈 + 中心
|
||
BuildDefaultProbes(axisLocal, bottom, _ComputedDiameter);
|
||
|
||
if (!editor)
|
||
{
|
||
// 运行时也确保 query arrays 充足
|
||
AllocateQueryArrays();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void BuildDefaultProbes(Vector3 axisLocal, Vector3 bottomLocal, float diameter)
|
||
{
|
||
// 以刚体局部空间为准，探针 offset 是“相对 COM 的局部偏移”
|
||
// 我们把探针放在 “底部投影点附近”，并沿“横向平面”撑开
|
||
float radius = diameter * 0.5f;
|
||
float ringR = radius * _ProbeRadiusRatio;
|
||
|
||
// 底部沿长轴方向略抬高，避免探针刚好在最底点导致 jitter
|
||
// 这里用“长轴”方向抬高，而不是简单的 localY
|
||
float lift = _ProbeLiftMeters;
|
||
if (lift <= 0f)
|
||
{
|
||
// 默认：半径的 10%
|
||
lift = radius * 0.10f;
|
||
}
|
||
|
||
Vector3 basePoint = bottomLocal + axisLocal * lift;
|
||
|
||
// 需要在“横向平面”找两条正交方向（在 rb local 坐标中）
|
||
// 任意取一个与 axisLocal 不平行的向量，构造正交基
|
||
Vector3 t1 = Vector3.Cross(axisLocal, Vector3.up);
|
||
if (t1.sqrMagnitude < 1e-6f) t1 = Vector3.Cross(axisLocal, Vector3.right);
|
||
t1.Normalize();
|
||
Vector3 t2 = Vector3.Cross(axisLocal, t1).normalized;
|
||
|
||
// 权重分配
|
||
float ringTotal = Mathf.Clamp01(_RingWeight);
|
||
float centerW = 1f - ringTotal;
|
||
float eachRingW = ringTotal / 4f;
|
||
|
||
// 探针点（rb local），最后转成 “相对 COM 的 local offset”
|
||
// 注意：我们使用 worldCenterOfMass 作为基准，所以这里要把 basePoint（rb local）转换成 offset-from-COM
|
||
Vector3 comLocal = transform.InverseTransformPoint(_RigidBody.worldCenterOfMass);
|
||
|
||
var probes = new Probe[5];
|
||
|
||
// 四周
|
||
probes[0] = new Probe { localOffsetFromCOM = (basePoint + t1 * ringR) - comLocal, weight = eachRingW };
|
||
probes[1] = new Probe { localOffsetFromCOM = (basePoint - t1 * ringR) - comLocal, weight = eachRingW };
|
||
probes[2] = new Probe { localOffsetFromCOM = (basePoint + t2 * ringR) - comLocal, weight = eachRingW };
|
||
probes[3] = new Probe { localOffsetFromCOM = (basePoint - t2 * ringR) - comLocal, weight = eachRingW };
|
||
|
||
// 底部中心
|
||
probes[4] = new Probe { localOffsetFromCOM = basePoint - comLocal, weight = Mathf.Max(0.0001f, centerW) };
|
||
|
||
_Probes = probes;
|
||
}
|
||
|
||
void AddCapsuleSamplePointsInRbLocal(CapsuleCollider cap, List<Vector3> outPtsRbLocal)
|
||
{
|
||
// 计算胶囊端点（世界） + 若干“半径点”，再转换到 rb local
|
||
// 胶囊在 cap.transform local：center, direction(0=x 1=y 2=z), height, radius
|
||
Transform ct = cap.transform;
|
||
|
||
Vector3 centerW = ct.TransformPoint(cap.center);
|
||
|
||
// direction axis in world
|
||
Vector3 axisW =
|
||
cap.direction == 0 ? ct.right :
|
||
cap.direction == 1 ? ct.up :
|
||
ct.forward;
|
||
|
||
axisW.Normalize();
|
||
|
||
// 处理缩放：radius 取垂直于轴的最大缩放分量（保守）
|
||
Vector3 s = ct.lossyScale;
|
||
float sx = Mathf.Abs(s.x);
|
||
float sy = Mathf.Abs(s.y);
|
||
float sz = Mathf.Abs(s.z);
|
||
|
||
float radiusScale;
|
||
float heightScale;
|
||
|
||
if (cap.direction == 0)
|
||
{
|
||
heightScale = sx;
|
||
radiusScale = Mathf.Max(sy, sz);
|
||
}
|
||
else if (cap.direction == 1)
|
||
{
|
||
heightScale = sy;
|
||
radiusScale = Mathf.Max(sx, sz);
|
||
}
|
||
else
|
||
{
|
||
heightScale = sz;
|
||
radiusScale = Mathf.Max(sx, sy);
|
||
}
|
||
|
||
float r = Mathf.Max(0.0005f, cap.radius * radiusScale);
|
||
float h = Mathf.Max(0.001f, cap.height * heightScale);
|
||
|
||
// 圆柱部分半长（端点到端点的距离为 h-2r）
|
||
float half = Mathf.Max(0f, (h * 0.5f) - r);
|
||
|
||
Vector3 p0W = centerW + axisW * half;
|
||
Vector3 p1W = centerW - axisW * half;
|
||
|
||
// 在世界空间构造两个与 axisW 正交的方向
|
||
Vector3 n1 = Vector3.Cross(axisW, Vector3.up);
|
||
if (n1.sqrMagnitude < 1e-6f) n1 = Vector3.Cross(axisW, Vector3.right);
|
||
n1.Normalize();
|
||
Vector3 n2 = Vector3.Cross(axisW, n1).normalized;
|
||
|
||
// 采样点：两个端点 + 端点的四周半径点 + 中心四周半径点（足够稳定估算整体 AABB）
|
||
AddWorldPoint(p0W, outPtsRbLocal);
|
||
AddWorldPoint(p1W, outPtsRbLocal);
|
||
|
||
AddWorldPoint(p0W + n1 * r, outPtsRbLocal);
|
||
AddWorldPoint(p0W - n1 * r, outPtsRbLocal);
|
||
AddWorldPoint(p0W + n2 * r, outPtsRbLocal);
|
||
AddWorldPoint(p0W - n2 * r, outPtsRbLocal);
|
||
|
||
AddWorldPoint(p1W + n1 * r, outPtsRbLocal);
|
||
AddWorldPoint(p1W - n1 * r, outPtsRbLocal);
|
||
AddWorldPoint(p1W + n2 * r, outPtsRbLocal);
|
||
AddWorldPoint(p1W - n2 * r, outPtsRbLocal);
|
||
|
||
AddWorldPoint(centerW + n1 * r, outPtsRbLocal);
|
||
AddWorldPoint(centerW - n1 * r, outPtsRbLocal);
|
||
AddWorldPoint(centerW + n2 * r, outPtsRbLocal);
|
||
AddWorldPoint(centerW - n2 * r, outPtsRbLocal);
|
||
}
|
||
|
||
void AddWorldPoint(Vector3 world, List<Vector3> outPtsRbLocal)
|
||
{
|
||
// rb local（即本脚本 transform 的 local）
|
||
// 注意：这里假设脚本挂在 Rigidbody 所在物体上（通常是这样）
|
||
outPtsRbLocal.Add(transform.InverseTransformPoint(world));
|
||
}
|
||
}
|
||
} |