mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-21 16:12:40 +08:00
509d73b27d
* PR1: add explicit function return type (#15311) * PR4: add explicit function return type (#15314) * [ci skip][AUTO]: Automated code generating update: 8843bfe54cd3f8e6f84432948716c8d130ecb233 (#15314) (#15357) Co-authored-by: cocos-robot <cocos-robot@cocos.com> * add function return type * fix version checking * fix return type --------- Co-authored-by: Cocos Robot <48829427+cocos-robot@users.noreply.github.com> Co-authored-by: cocos-robot <cocos-robot@cocos.com>
1311 lines
50 KiB
TypeScript
1311 lines
50 KiB
TypeScript
/*
|
||
Copyright (c) 2020-2023 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 documentation files (the "Software"), to deal
|
||
in the Software without restriction, including without limitation the rights to
|
||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||
of the Software, and to permit persons to whom the Software is furnished to do so,
|
||
subject to the following conditions:
|
||
|
||
The above copyright notice and this permission notice shall be included in
|
||
all copies or substantial portions of the Software.
|
||
|
||
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 } 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 { IVec3Like } from '../math/type-define';
|
||
import type { RenderingSubMesh } from '../../asset/assets';
|
||
import type { IRaySubMeshOptions, IRayModelOptions, IRayMeshOptions } from './spec';
|
||
import type { Model } from '../../render-scene/scene';
|
||
import type { Mesh } from '../../3d';
|
||
|
||
/**
|
||
* @en
|
||
* ray-plane intersect detect.
|
||
* @zh
|
||
* 射线与平面的相交性检测。
|
||
* @param ray @zh 要测试的射线。 @en The ray to test.
|
||
* @param plane @zh 要测试的平面。 @en The plane to test.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const rayPlane = (function () {
|
||
return function (ray: Ray, plane: Plane): number {
|
||
const denom = Vec3.dot(ray.d, plane.n);
|
||
if (Math.abs(denom) < Number.EPSILON) { return 0; }
|
||
const d = distance.point_plane(ray.o, plane);
|
||
const t = -d / 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 the triangle to test is double sided.
|
||
* @returns @zh 0 或 非 0,0 表示没有相交。@en 0 or not 0, 0 indicates there is no intersection.
|
||
*/
|
||
const rayTriangle = (function (): (ray: Ray, triangle: Triangle, doubleSided?: boolean) => number {
|
||
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): number {
|
||
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);
|
||
|
||
// 1. det < eps && det > -eps && doubleSided
|
||
// 2. det < eps && !doubleSided
|
||
// if true, the ray is parallel to the triangle plane
|
||
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;
|
||
// enlargeCoeff 1.0, compare uvLimits, if true, the ray is outside the triangle
|
||
if (u < 0 || u > 1) { return 0; }
|
||
|
||
Vec3.cross(qvec, tvec, ab);
|
||
const v = Vec3.dot(ray.d, qvec) * inv_det;
|
||
// if true, the ray is outside the triangle
|
||
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.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const raySphere = (function (): (ray: Ray, sphere: Sphere) => number {
|
||
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 要测试的 AABB。 @en The aabb to test.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const rayAABB = (function (): (ray: Ray, aabb: AABB) => number {
|
||
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): number {
|
||
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
|
||
* 射线和 OBB 的相交性检测。
|
||
* @param ray @zh 要测试的射线。 @en The ray to test.
|
||
* @param obb @zh 要测试的 OBB。 @en The OBB to test.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const rayOBB = (function (): (ray: Ray, obb: OBB) => number {
|
||
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.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const rayCapsule = (function (): (ray: Ray, capsule: Capsule) => number {
|
||
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): number {
|
||
const A = capsule.ellipseCenter0;
|
||
const B = capsule.ellipseCenter1;
|
||
const BA = Vec3.subtract(v3_1, B, A);
|
||
if (BA.length() < EPSILON) {
|
||
// deduce to sphere
|
||
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 vRayNorm = Vec3.normalize(v3_0, ray.d);
|
||
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(A);
|
||
} else {
|
||
sphere_0.center.set(B);
|
||
}
|
||
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 radiusSqr = capsule.radius * capsule.radius;
|
||
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
|
||
* line-plane intersect detect.
|
||
* @zh
|
||
* 线段与平面的相交性检测。
|
||
* @param line @zh 要测试的线段。 @en The line to test.
|
||
* @param plane @zh 要测试的平面。 @en The plane to test.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const linePlane = (function (): (line: Line, plane: Plane) => number {
|
||
const ab = new Vec3(0, 0, 0);
|
||
|
||
return function (line: Line, plane: Plane): number {
|
||
Vec3.subtract(ab, line.e, line.s);
|
||
const t = -distance.point_plane(line.s, plane) / 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.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const lineTriangle = (function (): (line: Line, triangle: Triangle, outPt?: Vec3) => number {
|
||
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
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.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
|
||
* 线段与OBB的相交性检测。
|
||
* @param line @zh 线段 @en The line to test.
|
||
* @param obb @zh OBB @en The OBB to test.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.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
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.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
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.no intersection
|
||
*/
|
||
const aabbWithAABB = (function (): (aabb1: AABB, aabb2: AABB) => boolean {
|
||
const aMin = new Vec3();
|
||
const aMax = new Vec3();
|
||
const bMin = new Vec3();
|
||
const bMax = new Vec3();
|
||
return function (aabb1: AABB, aabb2: AABB): boolean {
|
||
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[]): void {
|
||
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[]): void {
|
||
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): number[] {
|
||
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
|
||
* 轴对齐包围盒和OBB的相交性检测。
|
||
* @param aabb @zh 轴对齐包围盒 @en The aabb to test
|
||
* @param obb @zh OBB @en The OBB to test
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.no intersection
|
||
*/
|
||
const aabbWithOBB = (function (): (aabb: AABB, obb: OBB) => number {
|
||
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
|
||
* @returns @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
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.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 锥台
|
||
* @returns {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
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.no intersection
|
||
*/
|
||
const aabbFrustumAccurate = (function (): (aabb: AABB, frustum: Frustum) => number {
|
||
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
|
||
* Checks whether the OBB contains the point.
|
||
* @zh
|
||
* OBB 和点的相交性检测。
|
||
* @param obb @zh 参与测试的 OBB。 @en The OBB to test.
|
||
* @param point @zh 参与测试的点。 @en The point to test.
|
||
* @returns @zh 是否相交 @en The value indicates if there is an intersection.
|
||
*/
|
||
const obbPoint = (function (): (obb: OBB, point: Vec3) => boolean {
|
||
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
|
||
* OBB 和平面的相交性检测。
|
||
* @param obb @zh OBB @en The OBB to test
|
||
* @param plane @zh 平面 @en The plane to test
|
||
* @returns @zh 检测结果, 包含为 -1, 不包含为 0, 相交为 1 @en Test result, inside(back) = -1, outside(front) = 0, intersect = 1
|
||
*/
|
||
const obbPlane = (function (): (obb: OBB, plane: Plane) => number {
|
||
const absDot = function (n: Vec3, x: number, y: number, z: number): 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
|
||
* OBB 和锥台相交性检测,速度快,但有错误情况。
|
||
* @param obb @zh OBB @en The OBB to test.
|
||
* @param frustum @zh 锥台 @en The frustum to test.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
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
|
||
* OBB 和锥台相交性检测,正确处理大多数错误情况。
|
||
* @param obb @zh OBB @en The OBB to test
|
||
* @param frustum @zh 锥台 @en The frustum to test
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.no intersection
|
||
*/
|
||
const obbFrustumAccurate = (function (): (obb: OBB, frustum: Frustum) => number {
|
||
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
|
||
* OBB 和OBB的相交性检测。
|
||
* @param obb1 @zh OBB1 @en Obb 1 to test
|
||
* @param obb2 @zh OBB2 @en Obb 2 to test
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.no intersection
|
||
*/
|
||
const obbWithOBB = (function (): (obb1: OBB, obb2: OBB) => number {
|
||
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
|
||
* OBB 和胶囊体的相交性检测。
|
||
* @param obb @zh OBB @en The OBB to test.
|
||
* @param capsule @zh 胶囊体 @en The capsule to test.
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.
|
||
*/
|
||
const obbCapsule = (function (): (obb: OBB, capsule: Capsule) => boolean | 1 | 0 {
|
||
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): boolean | 1 | 0 {
|
||
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
|
||
* @returns @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
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.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
|
||
* @returns @zh 如果没有相交,返回 0 ,否则返回非 0。 @en zero if no intersection, otherwise returns a non-zero value.no intersection
|
||
*/
|
||
const sphereFrustumAccurate = (function (): (sphere: Sphere, frustum: Frustum) => number {
|
||
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
|
||
* @returns @zh 是否发生碰撞 @en true or false which indicates if there is an 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
|
||
* @returns @zh 是否发生碰撞 @en true or false which indicates if there is an intersection
|
||
*/
|
||
const sphereAABB = (function (): (sphere: Sphere, aabb: AABB) => boolean {
|
||
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
|
||
* 球和 OBB 的相交性检测。
|
||
* @param sphere @zh 参与测试的球。 @en The sphere to test.
|
||
* @param obb @zh 参与测试的 OBB。 @en The OBB to test.
|
||
* @returns @zh 是否发生碰撞。 @en true or false which indicates if there is an intersection.
|
||
*/
|
||
const sphereOBB = (function (): (sphere: Sphere, obb: OBB) => boolean {
|
||
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.
|
||
* @returns @zh 是否发生碰撞。 @en true or false which indicates if there is an intersection.
|
||
*/
|
||
const sphereCapsule = (function (): (sphere: Sphere, capsule: Capsule) => boolean {
|
||
const v3_0 = new Vec3();
|
||
const v3_1 = new Vec3();
|
||
return function (sphere: Sphere, capsule: Capsule): boolean {
|
||
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.
|
||
* @returns @zh 如果相交,返回 true,否则返回 false。 @en true if there is an intersection, otherwise returns false.
|
||
*/
|
||
const capsuleWithCapsule = (function (): (capsuleA: Capsule, capsuleB: Capsule) => boolean {
|
||
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): boolean {
|
||
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,
|
||
|
||
// As these functions depends on upper modules, so move the implementation to misc/intersect.ts.
|
||
// These functions are defined here to keep compatibility, they will be override in misc/intersect.ts.
|
||
raySubMesh: null as unknown as (ray: Ray, submesh: RenderingSubMesh, options?: IRaySubMeshOptions) => number,
|
||
rayMesh: null as unknown as (ray: Ray, mesh: Mesh, options?: IRayMeshOptions) => number,
|
||
rayModel: null as unknown as (r: Ray, model: Model, options?: IRayModelOptions) => number,
|
||
|
||
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): number {
|
||
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;
|