Files
cocos4/cocos/core/geometry/intersect.ts
T
troublemaker52025 387b994f91 Add CSM for v3.6.0 (#11120)
* Add CSM for v3.6.0

* fix CI error

* fix Ci error 2

* Limit soft shadow sampling range

* update

* add soft 5x PCF

* add warn ID

* sync CSM to native engine

* fix CI error

* add Performance Mode

* fix ci error

* fix ci error 2

* fix ci error 3

* add precisely tailored

* use CC_SHADOWMAP_FORMAT

* update

* Modify default parameters

* sync to native engine

* revert config file

* fix  ci error

* modify pr problem

* fix CI error

* fix ci error

* sync to js engine

* fix ci error

* fix cc_shadowMap not binding

* fix vulkan shadow effect error

* build effect

* fix ci error

* modify review

* fix ci error

* fix ci error 2

* delete unused interfaces

* fix ci error

* update

* update 2

* fix ci error

* delete csmDebugMode

* build effect

* use csmLeve to shadowCascadeLevel

* update
2022-06-07 14:30:49 +08:00

1507 lines
55 KiB
TypeScript

/*
Copyright (c) 2020 Xiamen Yaji Software Co., Ltd.
https://www.cocos.com/
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated engine source code (the "Software"), a limited,
worldwide, royalty-free, non-assignable, revocable and non-exclusive license
to use Cocos Creator solely to develop games on your target platforms. You shall
not use Cocos Creator software for developing other software or tools that's
used for developing games. You are not granted to publish, distribute,
sublicense, and/or sell copies of Cocos Creator.
The software or tools in this License Agreement are licensed, not sold.
Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
import { EPSILON, Mat3, Vec3, Mat4 } from '../math';
import { AABB } from './aabb';
import { Capsule } from './capsule';
import * as distance from './distance';
import enums from './enums';
import { Frustum } from './frustum';
import { Line } from './line';
import { OBB } from './obb';
import { Plane } from './plane';
import { Ray } from './ray';
import { Sphere } from './sphere';
import { Triangle } from './triangle';
import { PrimitiveMode } from '../gfx';
import { Mesh } from '../../3d/assets/mesh';
import { IBArray, RenderingSubMesh } from '../assets/rendering-sub-mesh';
import { IRaySubMeshOptions, ERaycastMode, IRaySubMeshResult, IRayMeshOptions, IRayModelOptions } from './spec';
import { IVec3Like } from '../math/type-define';
import { scene } from '../renderer';
/**
* @en
* ray-plane intersect detect.
* @zh
* 射线与平面的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param plane @zh 平面 @en The plane to test
* @return @zh 0 或 非0 @en 0 or not 0, 0 indicates there is no intersection
*/
const rayPlane = (function () {
const pt = new Vec3(0, 0, 0);
return function (ray: Ray, plane: Plane): number {
const denom = Vec3.dot(ray.d, plane.n);
if (Math.abs(denom) < Number.EPSILON) { return 0; }
Vec3.multiplyScalar(pt, plane.n, plane.d);
const t = Vec3.dot(Vec3.subtract(pt, pt, ray.o), plane.n) / denom;
if (t < 0) { return 0; }
return t;
};
}());
// based on http://fileadmin.cs.lth.se/cs/Personal/Tomas_Akenine-Moller/raytri/
/**
* @en
* ray-triangle intersect detect.
* @zh
* 射线与三角形的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param triangle @zh 三角形 @en The triangle to test
* @param doubleSided @zh 三角形是否为双面 @en Indicates whether it is double sided
* @return @zh 0 或 非0 @en 0 or not 0, 0 indicates there is no intersection
*/
const rayTriangle = (function () {
const ab = new Vec3(0, 0, 0);
const ac = new Vec3(0, 0, 0);
const pvec = new Vec3(0, 0, 0);
const tvec = new Vec3(0, 0, 0);
const qvec = new Vec3(0, 0, 0);
return function (ray: Ray, triangle: Triangle, doubleSided?: boolean) {
Vec3.subtract(ab, triangle.b, triangle.a);
Vec3.subtract(ac, triangle.c, triangle.a);
Vec3.cross(pvec, ray.d, ac);
const det = Vec3.dot(ab, pvec);
if (det < Number.EPSILON && (!doubleSided || det > -Number.EPSILON)) { return 0; }
const inv_det = 1 / det;
Vec3.subtract(tvec, ray.o, triangle.a);
const u = Vec3.dot(tvec, pvec) * inv_det;
if (u < 0 || u > 1) { return 0; }
Vec3.cross(qvec, tvec, ab);
const v = Vec3.dot(ray.d, qvec) * inv_det;
if (v < 0 || u + v > 1) { return 0; }
const t = Vec3.dot(ac, qvec) * inv_det;
return t < 0 ? 0 : t;
};
}());
/**
* @en
* ray-sphere intersect detect.
* @zh
* 射线和球的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param sphere @zh 球 @en The sphere to test
* @return @zh 0 或 非0 @en 0 or not 0, 0 indicates there is no intersection
*/
const raySphere = (function () {
const e = new Vec3(0, 0, 0);
return function (ray: Ray, sphere: Sphere): number {
const r = sphere.radius;
const c = sphere.center;
const o = ray.o;
const d = ray.d;
const rSq = r * r;
Vec3.subtract(e, c, o);
const eSq = e.lengthSqr();
const aLength = Vec3.dot(e, d); // assume ray direction already normalized
const fSq = rSq - (eSq - aLength * aLength);
if (fSq < 0) { return 0; }
const f = Math.sqrt(fSq);
const t = eSq < rSq ? aLength + f : aLength - f;
if (t < 0) { return 0; }
return t;
};
}());
/**
* @en
* ray-aabb intersect detect.
* @zh
* 射线和轴对齐包围盒的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
* @return @zh 0 或 非0 @en 0 or not 0, 0 indicates there is no intersection
*/
const rayAABB = (function () {
const min = new Vec3();
const max = new Vec3();
return function (ray: Ray, aabb: AABB): number {
Vec3.subtract(min, aabb.center, aabb.halfExtents);
Vec3.add(max, aabb.center, aabb.halfExtents);
return rayAABB2(ray, min, max);
};
}());
function rayAABB2 (ray: Ray, min: IVec3Like, max: IVec3Like) {
const o = ray.o; const d = ray.d;
const ix = 1 / d.x; const iy = 1 / d.y; const iz = 1 / d.z;
const t1 = (min.x - o.x) * ix;
const t2 = (max.x - o.x) * ix;
const t3 = (min.y - o.y) * iy;
const t4 = (max.y - o.y) * iy;
const t5 = (min.z - o.z) * iz;
const t6 = (max.z - o.z) * iz;
const tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4)), Math.min(t5, t6));
const tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4)), Math.max(t5, t6));
if (tmax < 0 || tmin > tmax) { return 0; }
return tmin > 0 ? tmin : tmax; // ray origin inside aabb
}
/**
* @en
* ray-obb intersect detect.
* @zh
* 射线和方向包围盒的相交性检测。
* @param ray @zh 射线 @en The ray
* @param obb @zh 方向包围盒 @en The obb to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const rayOBB = (function () {
let center = new Vec3();
let o = new Vec3();
let d = new Vec3();
const X = new Vec3();
const Y = new Vec3();
const Z = new Vec3();
const p = new Vec3();
const size = new Array<number>(3);
const f = new Array<number>(3);
const e = new Array<number>(3);
const t = new Array<number>(6);
return function (ray: Ray, obb: OBB): number {
size[0] = obb.halfExtents.x;
size[1] = obb.halfExtents.y;
size[2] = obb.halfExtents.z;
center = obb.center;
o = ray.o;
d = ray.d;
Vec3.set(X, obb.orientation.m00, obb.orientation.m01, obb.orientation.m02);
Vec3.set(Y, obb.orientation.m03, obb.orientation.m04, obb.orientation.m05);
Vec3.set(Z, obb.orientation.m06, obb.orientation.m07, obb.orientation.m08);
Vec3.subtract(p, center, o);
// The cos values of the ray on the X, Y, Z
f[0] = Vec3.dot(X, d);
f[1] = Vec3.dot(Y, d);
f[2] = Vec3.dot(Z, d);
// The projection length of P on X, Y, Z
e[0] = Vec3.dot(X, p);
e[1] = Vec3.dot(Y, p);
e[2] = Vec3.dot(Z, p);
for (let i = 0; i < 3; ++i) {
if (f[i] === 0) {
if (-e[i] - size[i] > 0 || -e[i] + size[i] < 0) {
return 0;
}
// Avoid div by 0!
f[i] = 0.0000001;
}
// min
t[i * 2 + 0] = (e[i] + size[i]) / f[i];
// max
t[i * 2 + 1] = (e[i] - size[i]) / f[i];
}
const tmin = Math.max(
Math.max(
Math.min(t[0], t[1]),
Math.min(t[2], t[3]),
),
Math.min(t[4], t[5]),
);
const tmax = Math.min(
Math.min(
Math.max(t[0], t[1]),
Math.max(t[2], t[3]),
),
Math.max(t[4], t[5]),
);
if (tmax < 0 || tmin > tmax) {
return 0;
}
return tmin > 0 ? tmin : tmax; // ray origin inside aabb
};
}());
/**
* @en
* ray-capsule intersect detect.
* @zh
* 射线和胶囊体的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param capsule @zh 胶囊体 @en The capsule to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const rayCapsule = (function () {
const v3_0 = new Vec3();
const v3_1 = new Vec3();
const v3_2 = new Vec3();
const v3_3 = new Vec3();
const v3_4 = new Vec3();
const v3_5 = new Vec3();
const v3_6 = new Vec3();
const sphere_0 = new Sphere();
return function (ray: Ray, capsule: Capsule) {
const radiusSqr = capsule.radius * capsule.radius;
const vRayNorm = Vec3.normalize(v3_0, ray.d);
const A = capsule.ellipseCenter0;
const B = capsule.ellipseCenter1;
const BA = Vec3.subtract(v3_1, B, A);
if (BA.equals(Vec3.ZERO)) {
sphere_0.radius = capsule.radius;
sphere_0.center.set(capsule.ellipseCenter0);
return intersect.raySphere(ray, sphere_0);
}
const O = ray.o;
const OA = Vec3.subtract(v3_2, O, A);
const VxBA = Vec3.cross(v3_3, vRayNorm, BA);
const a = VxBA.lengthSqr();
if (a === 0) {
sphere_0.radius = capsule.radius;
const BO = Vec3.subtract(v3_4, B, O);
if (OA.lengthSqr() < BO.lengthSqr()) {
sphere_0.center.set(capsule.ellipseCenter0);
} else {
sphere_0.center.set(capsule.ellipseCenter1);
}
return intersect.raySphere(ray, sphere_0);
}
const OAxBA = Vec3.cross(v3_4, OA, BA);
const ab2 = BA.lengthSqr();
const b = 2 * Vec3.dot(VxBA, OAxBA);
const c = OAxBA.lengthSqr() - (radiusSqr * ab2);
const d = b * b - 4 * a * c;
if (d < 0) { return 0; }
const t = (-b - Math.sqrt(d)) / (2 * a);
if (t < 0) {
sphere_0.radius = capsule.radius;
const BO = Vec3.subtract(v3_5, B, O);
if (OA.lengthSqr() < BO.lengthSqr()) {
sphere_0.center.set(capsule.ellipseCenter0);
} else {
sphere_0.center.set(capsule.ellipseCenter1);
}
return intersect.raySphere(ray, sphere_0);
} else {
// Limit intersection between the bounds of the cylinder's end caps.
const iPos = Vec3.scaleAndAdd(v3_5, ray.o, vRayNorm, t);
const iPosLen = Vec3.subtract(v3_6, iPos, A);
const tLimit = Vec3.dot(iPosLen, BA) / ab2;
if (tLimit >= 0 && tLimit <= 1) {
return t;
} else if (tLimit < 0) {
sphere_0.radius = capsule.radius;
sphere_0.center.set(capsule.ellipseCenter0);
return intersect.raySphere(ray, sphere_0);
} else if (tLimit > 1) {
sphere_0.radius = capsule.radius;
sphere_0.center.set(capsule.ellipseCenter1);
return intersect.raySphere(ray, sphere_0);
} else {
return 0;
}
}
};
}());
/**
* @en
* ray-subMesh intersect detect, in model space.
* @zh
* 在模型空间中,射线和子三角网格的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param subMesh @zh 子网格 @en The sub mesh to test
* @param options @zh 额外选项 @en Optional params
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const raySubMesh = (function () {
const tri = Triangle.create();
const deOpt: IRaySubMeshOptions = { distance: Infinity, doubleSided: false, mode: ERaycastMode.ANY };
let minDis = 0;
const fillResult = (m: ERaycastMode, d: number, i0: number, i1: number, i2: number, r?: IRaySubMeshResult[]) => {
if (m === ERaycastMode.CLOSEST) {
if (minDis > d || minDis === 0) {
minDis = d;
if (r) {
if (r.length === 0) {
r.push({ distance: d, vertexIndex0: i0 / 3, vertexIndex1: i1 / 3, vertexIndex2: i2 / 3 });
} else {
r[0].distance = d; r[0].vertexIndex0 = i0 / 3; r[0].vertexIndex1 = i1 / 3; r[0].vertexIndex2 = i2 / 3;
}
}
}
} else {
minDis = d;
if (r) r.push({ distance: d, vertexIndex0: i0 / 3, vertexIndex1: i1 / 3, vertexIndex2: i2 / 3 });
}
};
const narrowphase = (vb: Float32Array, ib: IBArray, pm: PrimitiveMode, ray: Ray, opt: IRaySubMeshOptions) => {
if (pm === PrimitiveMode.TRIANGLE_LIST) {
const cnt = ib.length;
for (let j = 0; j < cnt; j += 3) {
const i0 = ib[j] * 3;
const i1 = ib[j + 1] * 3;
const i2 = ib[j + 2] * 3;
Vec3.set(tri.a, vb[i0], vb[i0 + 1], vb[i0 + 2]);
Vec3.set(tri.b, vb[i1], vb[i1 + 1], vb[i1 + 2]);
Vec3.set(tri.c, vb[i2], vb[i2 + 1], vb[i2 + 2]);
const dist = intersect.rayTriangle(ray, tri, opt.doubleSided);
if (dist === 0 || dist > opt.distance) continue;
fillResult(opt.mode, dist, i0, i1, i2, opt.result);
if (opt.mode === ERaycastMode.ANY) return dist;
}
} else if (pm === PrimitiveMode.TRIANGLE_STRIP) {
const cnt = ib.length - 2;
let rev = 0;
for (let j = 0; j < cnt; j += 1) {
const i0 = ib[j - rev] * 3;
const i1 = ib[j + rev + 1] * 3;
const i2 = ib[j + 2] * 3;
Vec3.set(tri.a, vb[i0], vb[i0 + 1], vb[i0 + 2]);
Vec3.set(tri.b, vb[i1], vb[i1 + 1], vb[i1 + 2]);
Vec3.set(tri.c, vb[i2], vb[i2 + 1], vb[i2 + 2]);
rev = ~rev;
const dist = intersect.rayTriangle(ray, tri, opt.doubleSided);
if (dist === 0 || dist > opt.distance) continue;
fillResult(opt.mode, dist, i0, i1, i2, opt.result);
if (opt.mode === ERaycastMode.ANY) return dist;
}
} else if (pm === PrimitiveMode.TRIANGLE_FAN) {
const cnt = ib.length - 1;
const i0 = ib[0] * 3;
Vec3.set(tri.a, vb[i0], vb[i0 + 1], vb[i0 + 2]);
for (let j = 1; j < cnt; j += 1) {
const i1 = ib[j] * 3;
const i2 = ib[j + 1] * 3;
Vec3.set(tri.b, vb[i1], vb[i1 + 1], vb[i1 + 2]);
Vec3.set(tri.c, vb[i2], vb[i2 + 1], vb[i2 + 2]);
const dist = intersect.rayTriangle(ray, tri, opt.doubleSided);
if (dist === 0 || dist > opt.distance) continue;
fillResult(opt.mode, dist, i0, i1, i2, opt.result);
if (opt.mode === ERaycastMode.ANY) return dist;
}
}
return minDis;
};
return function (ray: Ray, submesh: RenderingSubMesh, options?: IRaySubMeshOptions) {
minDis = 0;
if (submesh.geometricInfo.positions.length === 0) return minDis;
const opt = options === undefined ? deOpt : options;
const min = submesh.geometricInfo.boundingBox.min;
const max = submesh.geometricInfo.boundingBox.max;
if (rayAABB2(ray, min, max)) {
const pm = submesh.primitiveMode;
const { positions: vb, indices: ib } = submesh.geometricInfo;
narrowphase(vb, ib!, pm, ray, opt);
}
return minDis;
};
}());
/**
* @en
* ray-mesh intersect detect, in model space.
* @zh
* 在模型空间中,射线和三角网格资源的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param mesh @zh 网格 @en The mesh to test
* @param options @zh 可选参数 @en Optional param
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const rayMesh = (function () {
let minDis = 0;
const deOpt: IRayMeshOptions = { distance: Infinity, doubleSided: false, mode: ERaycastMode.ANY };
return function (ray: Ray, mesh: Mesh, options?: IRayMeshOptions) {
minDis = 0;
const opt = options === undefined ? deOpt : options;
const length = mesh.renderingSubMeshes.length;
const min = mesh.struct.minPosition;
const max = mesh.struct.maxPosition;
if (min && max && !rayAABB2(ray, min, max)) return minDis;
for (let i = 0; i < length; i++) {
const sm = mesh.renderingSubMeshes[i];
const dis = raySubMesh(ray, sm, opt);
if (dis) {
if (opt.mode === ERaycastMode.CLOSEST) {
if (minDis === 0 || minDis > dis) {
minDis = dis;
if (opt.subIndices) opt.subIndices[0] = i;
}
} else {
minDis = dis;
if (opt.subIndices) opt.subIndices.push(i);
if (opt.mode === ERaycastMode.ANY) {
return dis;
}
}
}
}
if (minDis && opt.mode === ERaycastMode.CLOSEST) {
if (opt.result) {
opt.result[0].distance = minDis;
opt.result.length = 1;
}
if (opt.subIndices) opt.subIndices.length = 1;
}
return minDis;
};
}());
/**
* @en
* ray-model intersect detect, in world space.
* @zh
* 在世界空间中,射线和渲染模型的相交性检测。
* @param ray @zh 射线 @en The ray to test
* @param model @zh model @en The model to test
* @param options @zh 可选参数 @en Optional param
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const rayModel = (function () {
let minDis = 0;
const deOpt: IRayModelOptions = { distance: Infinity, doubleSided: false, mode: ERaycastMode.ANY };
const modelRay = new Ray();
const m4 = new Mat4();
return function (r: Ray, model: scene.Model, options?: IRayModelOptions) {
minDis = 0;
const opt = options === undefined ? deOpt : options;
const wb = model.worldBounds;
if (wb && !rayAABB(r, wb)) return minDis;
Ray.copy(modelRay, r);
if (model.node) {
Mat4.invert(m4, model.node.getWorldMatrix(m4));
Vec3.transformMat4(modelRay.o, r.o, m4);
Vec3.transformMat4Normal(modelRay.d, r.d, m4);
}
const subModels = model.subModels;
for (let i = 0; i < subModels.length; i++) {
const subMesh = subModels[i].subMesh;
const dis = raySubMesh(modelRay, subMesh, opt);
if (dis) {
if (opt.mode === ERaycastMode.CLOSEST) {
if (minDis === 0 || minDis > dis) {
minDis = dis;
if (opt.subIndices) opt.subIndices[0] = i;
}
} else {
minDis = dis;
if (opt.subIndices) opt.subIndices.push(i);
if (opt.mode === ERaycastMode.ANY) {
return dis;
}
}
}
}
if (minDis && opt.mode === ERaycastMode.CLOSEST) {
if (opt.result) {
opt.result[0].distance = minDis;
opt.result.length = 1;
}
if (opt.subIndices) opt.subIndices.length = 1;
}
return minDis;
};
}());
/**
* @en
* line-plane intersect detect.
* @zh
* 线段与平面的相交性检测。
* @param line @zh 线段 @en The line to test
* @param plane @zh 平面 @en The plane to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const linePlane = (function () {
const ab = new Vec3(0, 0, 0);
return function (line: Line, plane: Plane): number {
Vec3.subtract(ab, line.e, line.s);
const t = (plane.d - Vec3.dot(line.s, plane.n)) / Vec3.dot(ab, plane.n);
if (t < 0 || t > 1) { return 0; }
return t;
};
}());
/**
* @en
* line-triangle intersect detect.
* @zh
* 线段与三角形的相交性检测。
* @param line @zh 线段 @en The line to test
* @param triangle @zh 三角形 @en The triangle to test
* @param outPt @zh 可选,相交点 @en Optional out param, indicates the intersection point
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const lineTriangle = (function () {
const ab = new Vec3(0, 0, 0);
const ac = new Vec3(0, 0, 0);
const qp = new Vec3(0, 0, 0);
const ap = new Vec3(0, 0, 0);
const n = new Vec3(0, 0, 0);
const e = new Vec3(0, 0, 0);
return function (line: Line, triangle: Triangle, outPt?: Vec3): number {
Vec3.subtract(ab, triangle.b, triangle.a);
Vec3.subtract(ac, triangle.c, triangle.a);
Vec3.subtract(qp, line.s, line.e);
Vec3.cross(n, ab, ac);
const det = Vec3.dot(qp, n);
if (det <= 0.0) {
return 0;
}
Vec3.subtract(ap, line.s, triangle.a);
const t = Vec3.dot(ap, n);
if (t < 0 || t > det) {
return 0;
}
Vec3.cross(e, qp, ap);
let v = Vec3.dot(ac, e);
if (v < 0 || v > det) {
return 0;
}
let w = -Vec3.dot(ab, e);
if (w < 0.0 || v + w > det) {
return 0;
}
if (outPt) {
const invDet = 1.0 / det;
v *= invDet;
w *= invDet;
const u = 1.0 - v - w;
// outPt = u*a + v*d + w*c;
Vec3.set(outPt,
triangle.a.x * u + triangle.b.x * v + triangle.c.x * w,
triangle.a.y * u + triangle.b.y * v + triangle.c.y * w,
triangle.a.z * u + triangle.b.z * v + triangle.c.z * w);
}
return 1;
};
}());
const r_t = new Ray();
/**
* @en
* line-aabb intersect detect.
* @zh
* 线段与轴对齐包围盒的相交性检测
* @param line @zh 线段 @en The line to test
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
function lineAABB (line: Line, aabb: AABB): number {
r_t.o.set(line.s);
Vec3.subtract(r_t.d, line.e, line.s);
r_t.d.normalize();
const min = rayAABB(r_t, aabb);
const len = line.length();
if (min <= len) {
return min;
} else {
return 0;
}
}
/**
* @en
* line-obb intersect detect.
* @zh
* 线段与方向包围盒的相交性检测
* @param line @zh 线段 @en The line to test
* @param obb @zh 方向包围盒 @en The obb
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
function lineOBB (line: Line, obb: OBB): number {
r_t.o.set(line.s);
Vec3.subtract(r_t.d, line.e, line.s);
r_t.d.normalize();
const min = rayOBB(r_t, obb);
const len = line.length();
if (min <= len) {
return min;
} else {
return 0;
}
}
/**
* @en
* line-sphere intersect detect.
* @zh
* 线段与球的相交性检测
* @param line @zh 线段 @en The line to test
* @param sphere @zh 球 @en The sphere to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
function lineSphere (line: Line, sphere: Sphere): number {
r_t.o.set(line.s);
Vec3.subtract(r_t.d, line.e, line.s);
r_t.d.normalize();
const min = raySphere(r_t, sphere);
const len = line.length();
if (min <= len) {
return min;
} else {
return 0;
}
}
/**
* @en
* aabb-aabb intersect detect.
* @zh
* 轴对齐包围盒和轴对齐包围盒的相交性检测。
* @param aabb1 @zh 轴对齐包围盒1 @en aabb 1 to test
* @param aabb2 @zh 轴对齐包围盒2 @en aabb 2 to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const aabbWithAABB = (function () {
const aMin = new Vec3();
const aMax = new Vec3();
const bMin = new Vec3();
const bMax = new Vec3();
return function (aabb1: AABB, aabb2: AABB) {
Vec3.subtract(aMin, aabb1.center, aabb1.halfExtents);
Vec3.add(aMax, aabb1.center, aabb1.halfExtents);
Vec3.subtract(bMin, aabb2.center, aabb2.halfExtents);
Vec3.add(bMax, aabb2.center, aabb2.halfExtents);
return (aMin.x <= bMax.x && aMax.x >= bMin.x)
&& (aMin.y <= bMax.y && aMax.y >= bMin.y)
&& (aMin.z <= bMax.z && aMax.z >= bMin.z);
};
}());
function getAABBVertices (min: Vec3, max: Vec3, out: Vec3[]) {
Vec3.set(out[0], min.x, max.y, max.z);
Vec3.set(out[1], min.x, max.y, min.z);
Vec3.set(out[2], min.x, min.y, max.z);
Vec3.set(out[3], min.x, min.y, min.z);
Vec3.set(out[4], max.x, max.y, max.z);
Vec3.set(out[5], max.x, max.y, min.z);
Vec3.set(out[6], max.x, min.y, max.z);
Vec3.set(out[7], max.x, min.y, min.z);
}
function getOBBVertices (c: Vec3, e: Vec3, a1: Vec3, a2: Vec3, a3: Vec3, out: Vec3[]) {
Vec3.set(out[0],
c.x + a1.x * e.x + a2.x * e.y + a3.x * e.z,
c.y + a1.y * e.x + a2.y * e.y + a3.y * e.z,
c.z + a1.z * e.x + a2.z * e.y + a3.z * e.z);
Vec3.set(out[1],
c.x - a1.x * e.x + a2.x * e.y + a3.x * e.z,
c.y - a1.y * e.x + a2.y * e.y + a3.y * e.z,
c.z - a1.z * e.x + a2.z * e.y + a3.z * e.z);
Vec3.set(out[2],
c.x + a1.x * e.x - a2.x * e.y + a3.x * e.z,
c.y + a1.y * e.x - a2.y * e.y + a3.y * e.z,
c.z + a1.z * e.x - a2.z * e.y + a3.z * e.z);
Vec3.set(out[3],
c.x + a1.x * e.x + a2.x * e.y - a3.x * e.z,
c.y + a1.y * e.x + a2.y * e.y - a3.y * e.z,
c.z + a1.z * e.x + a2.z * e.y - a3.z * e.z);
Vec3.set(out[4],
c.x - a1.x * e.x - a2.x * e.y - a3.x * e.z,
c.y - a1.y * e.x - a2.y * e.y - a3.y * e.z,
c.z - a1.z * e.x - a2.z * e.y - a3.z * e.z);
Vec3.set(out[5],
c.x + a1.x * e.x - a2.x * e.y - a3.x * e.z,
c.y + a1.y * e.x - a2.y * e.y - a3.y * e.z,
c.z + a1.z * e.x - a2.z * e.y - a3.z * e.z);
Vec3.set(out[6],
c.x - a1.x * e.x + a2.x * e.y - a3.x * e.z,
c.y - a1.y * e.x + a2.y * e.y - a3.y * e.z,
c.z - a1.z * e.x + a2.z * e.y - a3.z * e.z);
Vec3.set(out[7],
c.x - a1.x * e.x - a2.x * e.y + a3.x * e.z,
c.y - a1.y * e.x - a2.y * e.y + a3.y * e.z,
c.z - a1.z * e.x - a2.z * e.y + a3.z * e.z);
}
function getInterval (vertices: any[] | Vec3[], axis: Vec3) {
let min = Vec3.dot(axis, vertices[0]); let max = min;
for (let i = 1; i < 8; ++i) {
const projection = Vec3.dot(axis, vertices[i]);
min = (projection < min) ? projection : min;
max = (projection > max) ? projection : max;
}
return [min, max];
}
/**
* @en
* aabb-obb intersect detect.
* @zh
* 轴对齐包围盒和方向包围盒的相交性检测。
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
* @param obb @zh 方向包围盒 @en The obb to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const aabbWithOBB = (function () {
const test = new Array(15);
for (let i = 0; i < 15; i++) {
test[i] = new Vec3(0, 0, 0);
}
const vertices = new Array(8);
const vertices2 = new Array(8);
for (let i = 0; i < 8; i++) {
vertices[i] = new Vec3(0, 0, 0);
vertices2[i] = new Vec3(0, 0, 0);
}
const min = new Vec3();
const max = new Vec3();
return function (aabb: AABB, obb: OBB): number {
Vec3.set(test[0], 1, 0, 0);
Vec3.set(test[1], 0, 1, 0);
Vec3.set(test[2], 0, 0, 1);
Vec3.set(test[3], obb.orientation.m00, obb.orientation.m01, obb.orientation.m02);
Vec3.set(test[4], obb.orientation.m03, obb.orientation.m04, obb.orientation.m05);
Vec3.set(test[5], obb.orientation.m06, obb.orientation.m07, obb.orientation.m08);
for (let i = 0; i < 3; ++i) { // Fill out rest of axis
Vec3.cross(test[6 + i * 3 + 0], test[i], test[3]);
Vec3.cross(test[6 + i * 3 + 1], test[i], test[4]);
Vec3.cross(test[6 + i * 3 + 1], test[i], test[5]);
}
Vec3.subtract(min, aabb.center, aabb.halfExtents);
Vec3.add(max, aabb.center, aabb.halfExtents);
getAABBVertices(min, max, vertices);
getOBBVertices(obb.center, obb.halfExtents, test[3], test[4], test[5], vertices2);
for (let j = 0; j < 15; ++j) {
const a = getInterval(vertices, test[j]);
const b = getInterval(vertices2, test[j]);
if (b[0] > a[1] || a[0] > b[1]) {
return 0; // Seperating axis found
}
}
return 1;
};
}());
/**
* @en
* aabb-plane intersect detect.
* @zh
* 轴对齐包围盒和平面的相交性检测。
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
* @param plane @zh 平面 @en The plane to test
* @return @zh 检测结果, 包含为 -1, 不包含为 0, 相交为 1 @en Test result, inside(back) = -1, outside(front) = 0, intersect = 1
*/
const aabbPlane = function (aabb: AABB, plane: Plane): number {
const r = aabb.halfExtents.x * Math.abs(plane.n.x)
+ aabb.halfExtents.y * Math.abs(plane.n.y)
+ aabb.halfExtents.z * Math.abs(plane.n.z);
const dot = Vec3.dot(plane.n, aabb.center);
if (dot + r < plane.d) { return -1; } else if (dot - r > plane.d) { return 0; }
return 1;
};
/**
* @en
* aabb-frustum intersect detect, faster but has false positive corner cases.
* @zh
* 轴对齐包围盒和锥台相交性检测,速度快,但有错误情况。
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
* @param frustum @zh 锥台 @en The frustum to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const aabbFrustum = function (aabb: AABB, frustum: Readonly<Frustum>): number {
for (let i = 0; i < frustum.planes.length; i++) {
// frustum plane normal points to the inside
if (aabbPlane(aabb, frustum.planes[i]) === -1) {
return 0;
}
} // completely outside
return 1;
};
/**
* @en
* aabb-frustum intersect detect, faster but false while frustum is completely inside the aabb.
* @zh
* 轴对齐包围盒和锥台的相交性检测。速度快,但是当锥台完全在aabb中时就会判断出错。
* @param {AABB} aabb 轴对齐包围盒
* @param {Frustum} frustum 锥台
* @return {number} aabb completely inside the frustum = 1, otherwise = 0
*/
const aabbFrustumCompletelyInside = function (aabb: AABB, frustum: Readonly<Frustum>): number {
for (let i = 0; i < frustum.planes.length; i++) {
// frustum plane normal points to the inside
if (aabbPlane(aabb, frustum.planes[i]) !== 0) {
return 0;
}
} // completely inside
return 1;
};
// https://cesium.com/blog/2017/02/02/tighter-frustum-culling-and-why-you-may-want-to-disregard-it/
/**
* @en
* aabb-frustum intersect, handles most of the false positives correctly.
* @zh
* 轴对齐包围盒和锥台相交性检测,正确处理大多数错误情况。
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
* @param frustum @zh 锥台 @en The frustum to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const aabbFrustumAccurate = (function () {
const tmp = new Array(8);
let out1 = 0; let out2 = 0;
for (let i = 0; i < tmp.length; i++) {
tmp[i] = new Vec3(0, 0, 0);
}
return function (aabb: AABB, frustum: Frustum): number {
let result = 0; let intersects = false;
// 1. aabb inside/outside frustum test
for (let i = 0; i < frustum.planes.length; i++) {
result = aabbPlane(aabb, frustum.planes[i]);
// frustum plane normal points to the inside
if (result === -1) return 0; // completely outside
else if (result === 1) { intersects = true; }
}
if (!intersects) { return 1; } // completely inside
// in case of false positives
// 2. frustum inside/outside aabb test
for (let i = 0; i < frustum.vertices.length; i++) {
Vec3.subtract(tmp[i], frustum.vertices[i], aabb.center);
}
out1 = 0, out2 = 0;
for (let i = 0; i < frustum.vertices.length; i++) {
if (tmp[i].x > aabb.halfExtents.x) { out1++; } else if (tmp[i].x < -aabb.halfExtents.x) { out2++; }
}
if (out1 === frustum.vertices.length || out2 === frustum.vertices.length) { return 0; }
out1 = 0; out2 = 0;
for (let i = 0; i < frustum.vertices.length; i++) {
if (tmp[i].y > aabb.halfExtents.y) { out1++; } else if (tmp[i].y < -aabb.halfExtents.y) { out2++; }
}
if (out1 === frustum.vertices.length || out2 === frustum.vertices.length) { return 0; }
out1 = 0; out2 = 0;
for (let i = 0; i < frustum.vertices.length; i++) {
if (tmp[i].z > aabb.halfExtents.z) { out1++; } else if (tmp[i].z < -aabb.halfExtents.z) { out2++; }
}
if (out1 === frustum.vertices.length || out2 === frustum.vertices.length) { return 0; }
return 1;
};
}());
/**
* @en
* obb contains the point.
* @zh
* 方向包围盒和点的相交性检测。
* @param obb @zh 方向包围盒 @en The obb to test
* @param point @zh 点 @en The point to test
* @return @zh 布尔值 @en The value indicates if there is a intersection
*/
const obbPoint = (function () {
const tmp = new Vec3(0, 0, 0); const m3 = new Mat3();
const lessThan = function (a: Vec3, b: Vec3): boolean { return Math.abs(a.x) < b.x && Math.abs(a.y) < b.y && Math.abs(a.z) < b.z; };
return function (obb: OBB, point: Vec3): boolean {
Vec3.subtract(tmp, point, obb.center);
Vec3.transformMat3(tmp, tmp, Mat3.transpose(m3, obb.orientation));
return lessThan(tmp, obb.halfExtents);
};
}());
/**
* @en
* obb-plane intersect detect.
* @zh
* 方向包围盒和平面的相交性检测。
* @param obb @zh 方向包围盒 @en The obb to test
* @param plane @zh 平面 @en The plane to test
* @return @zh 检测结果, 包含为 -1, 不包含为 0, 相交为 1 @en Test result, inside(back) = -1, outside(front) = 0, intersect = 1
*/
const obbPlane = (function () {
const absDot = function (n: Vec3, x: number, y: number, z: number) {
return Math.abs(n.x * x + n.y * y + n.z * z);
};
return function (obb: OBB, plane: Plane): number {
// Real-Time Collision Detection, Christer Ericson, p. 163.
const r = obb.halfExtents.x * absDot(plane.n, obb.orientation.m00, obb.orientation.m01, obb.orientation.m02)
+ obb.halfExtents.y * absDot(plane.n, obb.orientation.m03, obb.orientation.m04, obb.orientation.m05)
+ obb.halfExtents.z * absDot(plane.n, obb.orientation.m06, obb.orientation.m07, obb.orientation.m08);
const dot = Vec3.dot(plane.n, obb.center);
if (dot + r < plane.d) { return -1; } else if (dot - r > plane.d) { return 0; }
return 1;
};
}());
/**
* @en
* obb-frustum intersect, faster but has false positive corner cases.
* @zh
* 方向包围盒和锥台相交性检测,速度快,但有错误情况。
* @param obb @zh 方向包围盒 @en The obb to test
* @param frustum @zh 锥台 @en The frustum to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const obbFrustum = function (obb: OBB, frustum: Frustum): number {
for (let i = 0; i < frustum.planes.length; i++) {
// frustum plane normal points to the inside
if (obbPlane(obb, frustum.planes[i]) === -1) {
return 0;
}
} // completely outside
return 1;
};
// https://cesium.com/blog/2017/02/02/tighter-frustum-culling-and-why-you-may-want-to-disregard-it/
/**
* @en
* obb-frustum intersect, handles most of the false positives correctly.
* @zh
* 方向包围盒和锥台相交性检测,正确处理大多数错误情况。
* @param obb @zh 方向包围盒 @en The obb to test
* @param frustum @zh 锥台 @en The frustum to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const obbFrustumAccurate = (function () {
const tmp = new Array(8);
let dist = 0; let out1 = 0; let out2 = 0;
for (let i = 0; i < tmp.length; i++) {
tmp[i] = new Vec3(0, 0, 0);
}
const dot = function (n: Vec3, x: number, y: number, z: number): number {
return n.x * x + n.y * y + n.z * z;
};
return function (obb: OBB, frustum: Frustum): number {
let result = 0; let intersects = false;
// 1. obb inside/outside frustum test
for (let i = 0; i < frustum.planes.length; i++) {
result = obbPlane(obb, frustum.planes[i]);
// frustum plane normal points to the inside
if (result === -1) return 0; // completely outside
else if (result === 1) { intersects = true; }
}
if (!intersects) { return 1; } // completely inside
// in case of false positives
// 2. frustum inside/outside obb test
for (let i = 0; i < frustum.vertices.length; i++) {
Vec3.subtract(tmp[i], frustum.vertices[i], obb.center);
}
out1 = 0, out2 = 0;
for (let i = 0; i < frustum.vertices.length; i++) {
dist = dot(tmp[i], obb.orientation.m00, obb.orientation.m01, obb.orientation.m02);
if (dist > obb.halfExtents.x) { out1++; } else if (dist < -obb.halfExtents.x) { out2++; }
}
if (out1 === frustum.vertices.length || out2 === frustum.vertices.length) { return 0; }
out1 = 0; out2 = 0;
for (let i = 0; i < frustum.vertices.length; i++) {
dist = dot(tmp[i], obb.orientation.m03, obb.orientation.m04, obb.orientation.m05);
if (dist > obb.halfExtents.y) { out1++; } else if (dist < -obb.halfExtents.y) { out2++; }
}
if (out1 === frustum.vertices.length || out2 === frustum.vertices.length) { return 0; }
out1 = 0; out2 = 0;
for (let i = 0; i < frustum.vertices.length; i++) {
dist = dot(tmp[i], obb.orientation.m06, obb.orientation.m07, obb.orientation.m08);
if (dist > obb.halfExtents.z) { out1++; } else if (dist < -obb.halfExtents.z) { out2++; }
}
if (out1 === frustum.vertices.length || out2 === frustum.vertices.length) { return 0; }
return 1;
};
}());
/**
* @en
* obb-obb intersect detect.
* @zh
* 方向包围盒和方向包围盒的相交性检测。
* @param obb1 @zh 方向包围盒1 @en Obb 1 to test
* @param obb2 @zh 方向包围盒2 @en Obb 2 to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const obbWithOBB = (function () {
const test = new Array(15);
for (let i = 0; i < 15; i++) {
test[i] = new Vec3(0, 0, 0);
}
const vertices = new Array(8);
const vertices2 = new Array(8);
for (let i = 0; i < 8; i++) {
vertices[i] = new Vec3(0, 0, 0);
vertices2[i] = new Vec3(0, 0, 0);
}
return function (obb1: OBB, obb2: OBB): number {
Vec3.set(test[0], obb1.orientation.m00, obb1.orientation.m01, obb1.orientation.m02);
Vec3.set(test[1], obb1.orientation.m03, obb1.orientation.m04, obb1.orientation.m05);
Vec3.set(test[2], obb1.orientation.m06, obb1.orientation.m07, obb1.orientation.m08);
Vec3.set(test[3], obb2.orientation.m00, obb2.orientation.m01, obb2.orientation.m02);
Vec3.set(test[4], obb2.orientation.m03, obb2.orientation.m04, obb2.orientation.m05);
Vec3.set(test[5], obb2.orientation.m06, obb2.orientation.m07, obb2.orientation.m08);
for (let i = 0; i < 3; ++i) { // Fill out rest of axis
Vec3.cross(test[6 + i * 3 + 0], test[i], test[3]);
Vec3.cross(test[6 + i * 3 + 1], test[i], test[4]);
Vec3.cross(test[6 + i * 3 + 2], test[i], test[5]);
}
getOBBVertices(obb1.center, obb1.halfExtents, test[0], test[1], test[2], vertices);
getOBBVertices(obb2.center, obb2.halfExtents, test[3], test[4], test[5], vertices2);
for (let i = 0; i < 15; ++i) {
const a = getInterval(vertices, test[i]);
const b = getInterval(vertices2, test[i]);
if (b[0] > a[1] || a[0] > b[1]) {
return 0; // Seperating axis found
}
}
return 1;
};
}());
// https://github.com/diku-dk/bvh-tvcg18/blob/1fd3348c17bc8cf3da0b4ae60fdb8f2aa90a6ff0/FOUNDATION/GEOMETRY/GEOMETRY/include/overlap/geometry_overlap_obb_capsule.h
/**
* @en
* obb-capsule intersect detect.
* @zh
* 方向包围盒和胶囊体的相交性检测。
* @param obb @zh 方向包围盒 @en The obb to test
* @param capsule @zh 胶囊体 @en The capsule to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const obbCapsule = (function () {
const sphere_0 = new Sphere();
const v3_0 = new Vec3();
const v3_1 = new Vec3();
const v3_2 = new Vec3();
const v3_verts8 = new Array<Vec3>(8);
for (let i = 0; i < 8; i++) { v3_verts8[i] = new Vec3(); }
const v3_axis8 = new Array<Vec3>(8);
for (let i = 0; i < 8; i++) { v3_axis8[i] = new Vec3(); }
return function (obb: OBB, capsule: Capsule) {
const h = Vec3.squaredDistance(capsule.ellipseCenter0, capsule.ellipseCenter1);
if (h === 0) {
sphere_0.radius = capsule.radius;
sphere_0.center.set(capsule.ellipseCenter0);
return intersect.sphereOBB(sphere_0, obb);
} else {
v3_0.x = obb.orientation.m00;
v3_0.y = obb.orientation.m01;
v3_0.z = obb.orientation.m02;
v3_1.x = obb.orientation.m03;
v3_1.y = obb.orientation.m04;
v3_1.z = obb.orientation.m05;
v3_2.x = obb.orientation.m06;
v3_2.y = obb.orientation.m07;
v3_2.z = obb.orientation.m08;
getOBBVertices(obb.center, obb.halfExtents, v3_0, v3_1, v3_2, v3_verts8);
const axes = v3_axis8;
const a0 = Vec3.copy(axes[0], v3_0);
const a1 = Vec3.copy(axes[1], v3_1);
const a2 = Vec3.copy(axes[2], v3_2);
const C = Vec3.subtract(axes[3], capsule.center, obb.center);
C.normalize();
const B = Vec3.subtract(axes[4], capsule.ellipseCenter0, capsule.ellipseCenter1);
B.normalize();
Vec3.cross(axes[5], a0, B);
Vec3.cross(axes[6], a1, B);
Vec3.cross(axes[7], a2, B);
for (let i = 0; i < 8; ++i) {
const a = getInterval(v3_verts8, axes[i]);
const d0 = Vec3.dot(axes[i], capsule.ellipseCenter0);
const d1 = Vec3.dot(axes[i], capsule.ellipseCenter1);
const max_d = Math.max(d0, d1);
const min_d = Math.min(d0, d1);
const d_min = min_d - capsule.radius;
const d_max = max_d + capsule.radius;
if (d_min > a[1] || a[0] > d_max) {
return 0; // Seperating axis found
}
}
return 1;
}
};
}());
/**
* @en
* sphere-plane intersect, not necessarily faster than obb-plane,due to the length calculation of the
* plane normal to factor out the unnomalized plane distance.
* @zh
* 球与平面的相交性检测。
* @param sphere @zh 球 @en The sphere to test
* @param plane @zh 平面 @en The plane to test
* @return @zh 检测结果, 包含为 -1, 不包含为 0, 相交为 1 @en Test result, inside(back) = -1, outside(front) = 0, intersect = 1
*/
const spherePlane = function (sphere: Sphere, plane: Plane): number {
const dot = Vec3.dot(plane.n, sphere.center);
const r = sphere.radius * plane.n.length();
if (dot + r < plane.d) { return -1; } else if (dot - r > plane.d) { return 0; }
return 1;
};
/**
* @en
* sphere-frustum intersect, faster but has false positive corner cases.
* @zh
* 球和锥台的相交性检测,速度快,但有错误情况。
* @param sphere @zh 球 @en The sphere to test
* @param frustum @zh 锥台 @en The frustum to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const sphereFrustum = function (sphere: Sphere, frustum: Frustum): number {
for (let i = 0; i < frustum.planes.length; i++) {
// frustum plane normal points to the inside
if (spherePlane(sphere, frustum.planes[i]) === -1) {
return 0;
}
} // completely outside
return 1;
};
// https://stackoverflow.com/questions/20912692/view-frustum-culling-corner-cases
/**
* @en
* sphere-frustum intersect, handles the false positives correctly.
* @zh
* 球和锥台的相交性检测,正确处理大多数错误情况。
* @param sphere @zh 球 @en The sphere to test
* @param frustum @zh 锥台 @en The frustum to test
* @return @zh 0 或非 0 @en 0 or not 0, 0 indicates there is no intersection
*/
const sphereFrustumAccurate = (function () {
const pt = new Vec3(0, 0, 0); const map = [1, -1, 1, -1, 1, -1];
return function (sphere: Sphere, frustum: Frustum): number {
for (let i = 0; i < 6; i++) {
const plane = frustum.planes[i];
const r = sphere.radius; const c = sphere.center;
const n = plane.n; const d = plane.d;
const dot = Vec3.dot(n, c);
// frustum plane normal points to the inside
if (dot + r < d) return 0; // completely outside
else if (dot - r > d) { continue; }
// in case of false positives
// has false negatives, still working on it
Vec3.add(pt, c, Vec3.multiplyScalar(pt, n, r));
for (let j = 0; j < 6; j++) {
if (j === i || j === i + map[i]) { continue; }
const test = frustum.planes[j];
if (Vec3.dot(test.n, pt) < test.d) { return 0; }
}
}
return 1;
};
}());
/**
* @en
* sphere-sphere intersect detect.
* @zh
* 球和球的相交性检测。
* @param sphere0 @zh 球 0 @en The sphere A to test
* @param sphere1 @zh 球 1 @en The sphere B to test
* @return @zh 是否发生碰撞 @en true or false which indicates if there is a intersection
*/
const sphereWithSphere = function (sphere0: Sphere, sphere1: Sphere): boolean {
const r = sphere0.radius + sphere1.radius;
return Vec3.squaredDistance(sphere0.center, sphere1.center) < r * r;
};
/**
* @en
* sphere-aabb intersect detect.
* @zh
* 球和轴对齐包围盒的相交性检测。
* @param sphere @zh 球 @en The sphere to test
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
* @return @zh 是否发生碰撞 @en true or false which indicates if there is a intersection
*/
const sphereAABB = (function () {
const pt = new Vec3();
return function (sphere: Sphere, aabb: AABB): boolean {
distance.pt_point_aabb(pt, sphere.center, aabb);
return Vec3.squaredDistance(sphere.center, pt) < sphere.radius * sphere.radius;
};
}());
/**
* @en
* sphere-obb intersect detect.
* @zh
* 球和方向包围盒的相交性检测。
* @param sphere @zh 球 @en The sphere to test
* @param obb @zh 方向包围盒 @en The obb to test
* @return @zh 是否发生碰撞 @en true or false which indicates if there is a intersection
*/
const sphereOBB = (function () {
const pt = new Vec3();
return function (sphere: Sphere, obb: OBB): boolean {
distance.pt_point_obb(pt, sphere.center, obb);
return Vec3.squaredDistance(sphere.center, pt) < sphere.radius * sphere.radius;
};
}());
/**
* @en
* sphere-capsule intersect detect.
* @zh
* 球和胶囊体的相交性检测。
* @param sphere @zh 球 @en The sphere to test
* @param capsule @zh 胶囊体 @en The capsule to test
* @return @zh 是否发生碰撞 @en true or false which indicates if there is a intersection
*/
const sphereCapsule = (function () {
const v3_0 = new Vec3();
const v3_1 = new Vec3();
return function (sphere: Sphere, capsule: Capsule) {
const r = sphere.radius + capsule.radius;
const squaredR = r * r;
const h = Vec3.squaredDistance(capsule.ellipseCenter0, capsule.ellipseCenter1);
if (h === 0) {
return Vec3.squaredDistance(sphere.center, capsule.center) < squaredR;
} else {
Vec3.subtract(v3_0, sphere.center, capsule.ellipseCenter0);
Vec3.subtract(v3_1, capsule.ellipseCenter1, capsule.ellipseCenter0);
const t = Vec3.dot(v3_0, v3_1) / h;
if (t < 0) {
return Vec3.squaredDistance(sphere.center, capsule.ellipseCenter0) < squaredR;
} else if (t > 1) {
return Vec3.squaredDistance(sphere.center, capsule.ellipseCenter1) < squaredR;
} else {
Vec3.scaleAndAdd(v3_0, capsule.ellipseCenter0, v3_1, t);
return Vec3.squaredDistance(sphere.center, v3_0) < squaredR;
}
}
};
}());
// http://www.geomalgorithms.com/a07-_distance.html
/**
* @en
* capsule-capsule intersect detect.
* @zh
* 胶囊体和胶囊体的相交性检测。
* @param capsuleA @zh 胶囊体 A @en The capsule A to test
* @param capsuleB @zh 胶囊体 B @en The capsule B to test
* @return @zh 是否发生碰撞 @en true or false which indicates if there is a intersection
*/
const capsuleWithCapsule = (function () {
const v3_0 = new Vec3();
const v3_1 = new Vec3();
const v3_2 = new Vec3();
const v3_3 = new Vec3();
const v3_4 = new Vec3();
const v3_5 = new Vec3();
return function capsuleWithCapsule (capsuleA: Capsule, capsuleB: Capsule) {
const u = Vec3.subtract(v3_0, capsuleA.ellipseCenter1, capsuleA.ellipseCenter0);
const v = Vec3.subtract(v3_1, capsuleB.ellipseCenter1, capsuleB.ellipseCenter0);
const w = Vec3.subtract(v3_2, capsuleA.ellipseCenter0, capsuleB.ellipseCenter0);
const a = Vec3.dot(u, u); // always >= 0
const b = Vec3.dot(u, v);
const c = Vec3.dot(v, v); // always >= 0
const d = Vec3.dot(u, w);
const e = Vec3.dot(v, w);
const D = a * c - b * b; // always >= 0
let sN: number;
let sD = D; // sc = sN / sD, default sD = D >= 0
let tN: number;
let tD = D; // tc = tN / tD, default tD = D >= 0
// compute the line parameters of the two closest points
if (D < EPSILON) { // the lines are almost parallel
sN = 0.0; // force using point P0 on segment S1
sD = 1.0; // to prevent possible division by 0.0 later
tN = e;
tD = c;
} else { // get the closest points on the infinite lines
sN = (b * e - c * d);
tN = (a * e - b * d);
if (sN < 0.0) { // sc < 0 => the s=0 edge is visible
sN = 0.0;
tN = e;
tD = c;
} else if (sN > sD) { // sc > 1 => the s=1 edge is visible
sN = sD;
tN = e + b;
tD = c;
}
}
if (tN < 0.0) { // tc < 0 => the t=0 edge is visible
tN = 0.0;
// recompute sc for this edge
if (-d < 0.0) {
sN = 0.0;
} else if (-d > a) {
sN = sD;
} else {
sN = -d;
sD = a;
}
} else if (tN > tD) { // tc > 1 => the t=1 edge is visible
tN = tD;
// recompute sc for this edge
if ((-d + b) < 0.0) {
sN = 0;
} else if ((-d + b) > a) {
sN = sD;
} else {
sN = (-d + b);
sD = a;
}
}
// finally do the division to get sc and tc
const sc = (Math.abs(sN) < EPSILON ? 0.0 : sN / sD);
const tc = (Math.abs(tN) < EPSILON ? 0.0 : tN / tD);
// get the difference of the two closest points
const dP = v3_3;
dP.set(w);
dP.add(Vec3.multiplyScalar(v3_4, u, sc));
dP.subtract(Vec3.multiplyScalar(v3_5, v, tc));
const radius = capsuleA.radius + capsuleB.radius;
return dP.lengthSqr() < radius * radius;
};
}());
/**
* @en
* Algorithm of intersect detect for basic geometry.
* @zh
* 基础几何的相交性检测算法。
*/
const intersect = {
raySphere,
rayAABB,
rayOBB,
rayPlane,
rayTriangle,
rayCapsule,
raySubMesh,
rayMesh,
rayModel,
lineSphere,
lineAABB,
lineOBB,
linePlane,
lineTriangle,
sphereWithSphere,
sphereAABB,
sphereOBB,
spherePlane,
sphereFrustum,
sphereFrustumAccurate,
sphereCapsule,
aabbWithAABB,
aabbWithOBB,
aabbPlane,
aabbFrustum,
aabbFrustumAccurate,
obbWithOBB,
obbPlane,
obbFrustum,
obbFrustumAccurate,
obbPoint,
obbCapsule,
aabbFrustumCompletelyInside,
capsuleWithCapsule,
/**
* @en Check intersection between two geometries, it accept all basic geometry types in [[geometry]] module.
* @zh 两个几何体的相交性检测,可填入 [[geometry]] 模块中的基础几何形状。
* @param g1 @en The first geometry. @zh 第一个几何体。
* @param g2 @en The second geometry. @zh 第二个几何体。
* @param outPt @en A 3d point to store the intersection point result, only part of the geometries support this.
* @zh 可选,用于保存相交点的输出对象。(注:仅部分形状的检测带有这个返回值)
*/
resolve (g1: any, g2: any, outPt = null) {
const type1 = g1._type; const type2 = g2._type;
const resolver = this[type1 | type2] as (...args: any) => number;
return type1 < type2 ? resolver(g1, g2, outPt) : resolver(g2, g1, outPt);
},
};
intersect[enums.SHAPE_RAY | enums.SHAPE_SPHERE] = raySphere;
intersect[enums.SHAPE_RAY | enums.SHAPE_AABB] = rayAABB;
intersect[enums.SHAPE_RAY | enums.SHAPE_OBB] = rayOBB;
intersect[enums.SHAPE_RAY | enums.SHAPE_PLANE] = rayPlane;
intersect[enums.SHAPE_RAY | enums.SHAPE_TRIANGLE] = rayTriangle;
intersect[enums.SHAPE_RAY | enums.SHAPE_CAPSULE] = rayCapsule;
intersect[enums.SHAPE_LINE | enums.SHAPE_SPHERE] = lineSphere;
intersect[enums.SHAPE_LINE | enums.SHAPE_AABB] = lineAABB;
intersect[enums.SHAPE_LINE | enums.SHAPE_OBB] = lineOBB;
intersect[enums.SHAPE_LINE | enums.SHAPE_PLANE] = linePlane;
intersect[enums.SHAPE_LINE | enums.SHAPE_TRIANGLE] = lineTriangle;
intersect[enums.SHAPE_SPHERE] = sphereWithSphere;
intersect[enums.SHAPE_SPHERE | enums.SHAPE_AABB] = sphereAABB;
intersect[enums.SHAPE_SPHERE | enums.SHAPE_OBB] = sphereOBB;
intersect[enums.SHAPE_SPHERE | enums.SHAPE_PLANE] = spherePlane;
intersect[enums.SHAPE_SPHERE | enums.SHAPE_FRUSTUM] = sphereFrustum;
intersect[enums.SHAPE_SPHERE | enums.SHAPE_FRUSTUM_ACCURATE] = sphereFrustumAccurate;
intersect[enums.SHAPE_SPHERE | enums.SHAPE_CAPSULE] = sphereCapsule;
intersect[enums.SHAPE_AABB] = aabbWithAABB;
intersect[enums.SHAPE_AABB | enums.SHAPE_OBB] = aabbWithOBB;
intersect[enums.SHAPE_AABB | enums.SHAPE_PLANE] = aabbPlane;
intersect[enums.SHAPE_AABB | enums.SHAPE_FRUSTUM] = aabbFrustum;
intersect[enums.SHAPE_AABB | enums.SHAPE_FRUSTUM_ACCURATE] = aabbFrustumAccurate;
intersect[enums.SHAPE_OBB] = obbWithOBB;
intersect[enums.SHAPE_OBB | enums.SHAPE_PLANE] = obbPlane;
intersect[enums.SHAPE_OBB | enums.SHAPE_FRUSTUM] = obbFrustum;
intersect[enums.SHAPE_OBB | enums.SHAPE_FRUSTUM_ACCURATE] = obbFrustumAccurate;
intersect[enums.SHAPE_OBB | enums.SHAPE_CAPSULE] = obbCapsule;
intersect[enums.SHAPE_CAPSULE] = capsuleWithCapsule;
export default intersect;