418 lines
15 KiB
TypeScript
418 lines
15 KiB
TypeScript
import * as THREE from 'three';
|
|
import { CONTAINED, ExtendedTriangle, INTERSECTED, NOT_INTERSECTED } from 'three-mesh-bvh';
|
|
import { CircularFrustum } from './circularFrustum';
|
|
import type { Id } from '../types';
|
|
|
|
export type TriangleVertexHitDetail = {
|
|
kind: 'vertex',
|
|
index: 0 | 1 | 2,
|
|
id?: Id,
|
|
}
|
|
export type TriangleEdgeHitDetail = {
|
|
kind: 'edge',
|
|
index: 0 | 1 | 2, // edge 0=AB, 1=BC, 2=CA
|
|
id?: Id,
|
|
}
|
|
export type TriangleFaceHitDetail = {
|
|
kind: 'face',
|
|
id?: Id,
|
|
}
|
|
|
|
export type TriangleHitDetail = TriangleVertexHitDetail | TriangleEdgeHitDetail | TriangleFaceHitDetail;
|
|
|
|
export type Visibility = 'visible' | 'backface'; // | 'occluded'
|
|
|
|
export type Intersection = {
|
|
object: THREE.Object3D,
|
|
point: THREE.Vector3, // world-space closest hit point
|
|
depth: number, // depth along frustum axis
|
|
triangle: { a: THREE.Vector3, b: THREE.Vector3, c: THREE.Vector3 },
|
|
triHit?: TriangleHitDetail,
|
|
visibility: Visibility,
|
|
}
|
|
|
|
export type BaseHitResult = {
|
|
intersection: Intersection,
|
|
}
|
|
|
|
export type FaceHitResult = BaseHitResult & {
|
|
kind: 'face',
|
|
id?: Id,
|
|
faceId: Id,
|
|
}
|
|
|
|
export type EdgeHitResult = BaseHitResult & {
|
|
kind: 'edge',
|
|
id?: Id,
|
|
faceId: Id,
|
|
}
|
|
|
|
export type VertexHitResult = BaseHitResult & {
|
|
kind: 'vertex',
|
|
id?: Id,
|
|
faceId: Id,
|
|
}
|
|
|
|
export type HitResult = FaceHitResult | EdgeHitResult | VertexHitResult;
|
|
|
|
export type HitResults = {
|
|
hits: HitResult[];
|
|
}
|
|
|
|
export type CircularFrustumIntersectionOptions = {
|
|
findAll?: boolean; // defaults to false
|
|
filter?: (object: THREE.Object3D) => boolean; // defaults to every object
|
|
}
|
|
|
|
export type IntersectionResult = 'NOT_INTERSECTED' | 'INTERSECTED' | 'CONTAINED';
|
|
|
|
export function intersectionResultToBvh(value: IntersectionResult): typeof NOT_INTERSECTED | typeof INTERSECTED | typeof CONTAINED {
|
|
switch (value) {
|
|
case 'NOT_INTERSECTED':
|
|
return NOT_INTERSECTED;
|
|
case 'INTERSECTED':
|
|
return INTERSECTED;
|
|
case 'CONTAINED':
|
|
return CONTAINED;
|
|
}
|
|
}
|
|
|
|
const BARYCENTRIC_EPSILON = 1e-1;
|
|
|
|
function classifyTriangleHit(
|
|
point: THREE.Vector3,
|
|
tri: ExtendedTriangle,
|
|
vertexIds?: [Id, Id, Id],
|
|
): TriangleHitDetail {
|
|
// Compute barycentric coords via areas
|
|
const ab = tri.b.clone().sub(tri.a);
|
|
const ac = tri.c.clone().sub(tri.a);
|
|
const ap = point.clone().sub(tri.a);
|
|
|
|
const d00 = ab.dot(ab);
|
|
const d01 = ab.dot(ac);
|
|
const d11 = ac.dot(ac);
|
|
const d20 = ap.dot(ab);
|
|
const d21 = ap.dot(ac);
|
|
const denom = d00 * d11 - d01 * d01;
|
|
|
|
const v = (d11 * d20 - d01 * d21) / denom; // weight of b
|
|
const w = (d00 * d21 - d01 * d20) / denom; // weight of c
|
|
const u = 1 - v - w; // weight of a
|
|
|
|
const eps = 1 - BARYCENTRIC_EPSILON;
|
|
const onA = u > eps;
|
|
const onB = v > eps;
|
|
const onC = w > eps;
|
|
|
|
if (onA) return { kind: 'vertex', index: 0, id: vertexIds?.[0] };
|
|
if (onB) return { kind: 'vertex', index: 1, id: vertexIds?.[1] };
|
|
if (onC) return { kind: 'vertex', index: 2, id: vertexIds?.[2] };
|
|
|
|
const onAB = w < BARYCENTRIC_EPSILON; // u+v≈1, w≈0
|
|
const onBC = u < BARYCENTRIC_EPSILON;
|
|
const onCA = v < BARYCENTRIC_EPSILON;
|
|
|
|
if (onAB) return { kind: 'edge', index: 0, id: `${vertexIds?.[0]}-${vertexIds?.[1]}` };
|
|
if (onBC) return { kind: 'edge', index: 1, id: `${vertexIds?.[1]}-${vertexIds?.[2]}` };
|
|
if (onCA) return { kind: 'edge', index: 2, id: `${vertexIds?.[2]}-${vertexIds?.[0]}` };
|
|
|
|
return { kind: 'face' };
|
|
}
|
|
|
|
export class CircularFrustumIntersection {
|
|
public readonly frustum: CircularFrustum;
|
|
|
|
constructor(frustum: CircularFrustum) {
|
|
this.frustum = frustum;
|
|
}
|
|
|
|
public insersectsSphere(sphere: THREE.Sphere): 'NOT_INTERSECTED' | number {
|
|
return CircularFrustumIntersection.insersectsSphere(sphere, this.frustum);
|
|
}
|
|
|
|
/**
|
|
* sphere and frustum both should be in the same coordinate space (local or world)
|
|
*
|
|
* Uses the Barros / van den Bergen separating-axis approach:
|
|
* - Check whether the sphere centre is inside the cone (fast path)
|
|
* - Otherwise check the distance from the sphere centre to the
|
|
* nearest cone surface (lateral face + apex cap)
|
|
*
|
|
* @returns axial depth of sphere center or NOT_INTERSECTED
|
|
*/
|
|
public static insersectsSphere(sphere: THREE.Sphere, frustum: CircularFrustum): 'NOT_INTERSECTED' | number {
|
|
const toCenter = sphere.center.clone().sub(frustum.apex);
|
|
const axialDist = toCenter.dot(frustum.axisNormalized);
|
|
|
|
if (axialDist + sphere.radius < 0) // behind the apex entirely
|
|
return 'NOT_INTERSECTED';
|
|
|
|
const lateralDist = toCenter.clone().addScaledVector(frustum.axisNormalized, -axialDist).length();
|
|
const distToConeEdge = lateralDist * frustum.cosHalfAngle - axialDist * frustum.sinHalfAngle;
|
|
|
|
if (distToConeEdge > sphere.radius) // fully outside lateral surface
|
|
return 'NOT_INTERSECTED';
|
|
|
|
return axialDist;
|
|
}
|
|
|
|
public intersectsBox(box: THREE.Box3): IntersectionResult {
|
|
return CircularFrustumIntersection.intersectsBox(box, this.frustum);
|
|
}
|
|
|
|
// box and this.frustum both should be in the same coordinate space (local or world)
|
|
public static intersectsBox(box: THREE.Box3, frustum: CircularFrustum): IntersectionResult {
|
|
const sphere = new THREE.Sphere();
|
|
box.getBoundingSphere(sphere);
|
|
if (CircularFrustumIntersection.insersectsSphere(sphere, frustum) === 'NOT_INTERSECTED')
|
|
return 'NOT_INTERSECTED';
|
|
|
|
// Check if all 8 corners are inside — if so, CONTAINED
|
|
const corners = Array(8)
|
|
.fill(0)
|
|
.map((_, i) => new THREE.Vector3(
|
|
i & 1 ? box.max.x : box.min.x,
|
|
i & 2 ? box.max.y : box.min.y,
|
|
i & 4 ? box.max.z : box.min.z,
|
|
));
|
|
const allInside = corners.every((c) => CircularFrustumIntersection.pointAxialDepth(c, frustum) !== 'NOT_INTERSECTED');
|
|
return allInside
|
|
? 'CONTAINED'
|
|
: 'INTERSECTED';
|
|
}
|
|
|
|
public pointAxialDepth(point: THREE.Vector3): 'NOT_INTERSECTED' | number {
|
|
return CircularFrustumIntersection.pointAxialDepth(point, this.frustum);
|
|
}
|
|
|
|
public static pointAxialDepth(point: THREE.Vector3, frustum: CircularFrustum): 'NOT_INTERSECTED' | number {
|
|
const toPoint = point.clone().sub(frustum.apex);
|
|
const dist = toPoint.length();
|
|
if (dist === 0)
|
|
return 0;
|
|
|
|
const axialDist = toPoint.dot(frustum.axisNormalized);
|
|
const cosAngle = axialDist / dist;
|
|
return cosAngle >= frustum.cosHalfAngle
|
|
? axialDist
|
|
: 'NOT_INTERSECTED';
|
|
}
|
|
|
|
//world-space to an object's local space
|
|
private toObjectLocalSpace(invWorldMatrix: THREE.Matrix4): CircularFrustum {
|
|
return this.frustum.transform(invWorldMatrix);
|
|
}
|
|
|
|
public intersectMesh(
|
|
mesh: THREE.Mesh,
|
|
findAll: boolean,
|
|
): Intersection[] {
|
|
const geometry = mesh.geometry;
|
|
if (!geometry)
|
|
return [];
|
|
|
|
const matrix = mesh.matrixWorld;
|
|
const matrixInverted = matrix.clone().invert(); // world -> local matrix
|
|
const worldFrustum = this.frustum;
|
|
const localFrustum = this.toObjectLocalSpace(matrixInverted);
|
|
|
|
// quick check for bounding sphere
|
|
if (!geometry.boundingSphere)
|
|
geometry.computeBoundingSphere();
|
|
const boundingSphere = geometry.boundingSphere!.clone().applyMatrix4(matrix);
|
|
if (this.insersectsSphere(boundingSphere) === 'NOT_INTERSECTED')
|
|
return [];
|
|
|
|
function getGeometryVertextIdByIndex(vertexIndex: number): Id {
|
|
return mesh.userData.vertexIds[vertexIndex];
|
|
}
|
|
|
|
function getGeometryVertextIds(triIndex: number): [Id, Id, Id] {
|
|
return geometry.index
|
|
? [
|
|
getGeometryVertextIdByIndex(geometry.index.array[triIndex * 3]),
|
|
getGeometryVertextIdByIndex(geometry.index.array[triIndex * 3 + 1]),
|
|
getGeometryVertextIdByIndex(geometry.index.array[triIndex * 3 + 2]),
|
|
]
|
|
: ['', '', ''];
|
|
}
|
|
|
|
const axisRay = new THREE.Ray(localFrustum.apex, localFrustum.axisNormalized);
|
|
|
|
function tryBestPoint(v: THREE.Vector3, best: { depth: number, local?: THREE.Vector3 }) {
|
|
const d = CircularFrustumIntersection.pointAxialDepth(v, localFrustum);
|
|
if (d !== 'NOT_INTERSECTED' && d < best.depth) {
|
|
best.depth = d as number;
|
|
best.local = v.clone();
|
|
}
|
|
};
|
|
|
|
const results: Intersection[] = [];
|
|
|
|
if (!geometry.boundsTree)
|
|
geometry.computeBoundsTree();
|
|
const bvh = geometry.boundsTree;
|
|
if (!bvh)
|
|
throw new Error('No BVH found for a mesh');
|
|
bvh.shapecast({
|
|
intersectsBounds: (box: THREE.Box3) => intersectionResultToBvh(CircularFrustumIntersection.intersectsBox(box, localFrustum)),
|
|
|
|
intersectsTriangle: (tri: ExtendedTriangle, triIndex: number, contained: boolean) => {
|
|
const tiangleVertexIds = getGeometryVertextIds(triIndex);
|
|
|
|
const normal = new THREE.Vector3();
|
|
tri.getNormal(normal);
|
|
const facingRatio = normal.dot(localFrustum.axisNormalized);
|
|
// normal orientation is same as frusum axis means triangle is faced way from camera
|
|
const visibility: Visibility = facingRatio >= 0 ? 'backface' : 'visible';
|
|
|
|
if (contained) {
|
|
const worldPoint = tri.a.clone().applyMatrix4(mesh.matrixWorld);
|
|
const depth = worldFrustum.axisNormalized.dot(worldPoint.clone().sub(worldFrustum.apex));
|
|
results.push({
|
|
object: mesh,
|
|
point: worldPoint,
|
|
depth,
|
|
triangle: tri,
|
|
triHit: classifyTriangleHit(tri.a, tri, tiangleVertexIds),
|
|
visibility,
|
|
// vertexIds: tiangleVertexIds,
|
|
});
|
|
return !findAll;
|
|
}
|
|
|
|
let bestPoint: { depth: number, local?: THREE.Vector3 } = { depth: Infinity, local: undefined };
|
|
|
|
// step 1: test vertices
|
|
tryBestPoint(tri.a, bestPoint);
|
|
tryBestPoint(tri.b, bestPoint);
|
|
tryBestPoint(tri.c, bestPoint);
|
|
|
|
// step 2: edges for a triangle that straddle the cone surface
|
|
// for each edge, find the point closest to the frustum axis ray, and also the point closest to the apex.
|
|
const edges: [THREE.Vector3, THREE.Vector3][] = [
|
|
[tri.a, tri.b],
|
|
[tri.b, tri.c],
|
|
[tri.c, tri.a],
|
|
];
|
|
|
|
for (const [a, b] of edges) {
|
|
const edge = b.clone().sub(a);
|
|
const toA = a.clone().sub(localFrustum.apex);
|
|
|
|
// Closest point on edge segment to the axis ray
|
|
const edgeDir = edge.clone().normalize();
|
|
const axisDotEdge = localFrustum.axisNormalized.dot(edgeDir);
|
|
const denom = 1 - axisDotEdge * axisDotEdge;
|
|
|
|
if (Math.abs(denom) > 1e-10) {
|
|
const t = (
|
|
localFrustum.axisNormalized.dot(toA) * axisDotEdge
|
|
- toA.dot(edgeDir)
|
|
) / denom;
|
|
const edgeLen = edge.length();
|
|
const tClamped = Math.max(0, Math.min(edgeLen, t));
|
|
const pointOnEdge = a.clone().addScaledVector(edgeDir, tClamped);
|
|
tryBestPoint(pointOnEdge, bestPoint);
|
|
}
|
|
|
|
// Closest point on edge to the apex itself
|
|
const tApex = Math.max(0, Math.min(1, -toA.dot(edge) / edge.lengthSq()));
|
|
tryBestPoint(a.clone().addScaledVector(edge, tApex), bestPoint);
|
|
}
|
|
|
|
// step 3: closest point on triangle face to the apex
|
|
const closestOnFace = new THREE.Vector3();
|
|
tri.closestPointToPoint(localFrustum.apex, closestOnFace);
|
|
if (!isNaN(closestOnFace.x))
|
|
tryBestPoint(closestOnFace, bestPoint);
|
|
|
|
// step 3: large faces that frustum (its axis) passes through
|
|
const faceHit = new THREE.Vector3();
|
|
if (axisRay.intersectTriangle(tri.a, tri.b, tri.c, false, faceHit)) {
|
|
tryBestPoint(faceHit, bestPoint);
|
|
}
|
|
|
|
if (bestPoint.local) {
|
|
const worldPoint = bestPoint.local.clone().applyMatrix4(mesh.matrixWorld);
|
|
const worldDepth = worldFrustum.axisNormalized.dot(worldPoint.clone().sub(worldFrustum.apex));
|
|
const { a, b, c } = tri;
|
|
results.push({
|
|
object: mesh,
|
|
point: worldPoint,
|
|
depth: worldDepth,
|
|
triangle: { a, b, c },
|
|
triHit: classifyTriangleHit(bestPoint.local, tri, tiangleVertexIds),
|
|
visibility,
|
|
});
|
|
return !findAll;
|
|
}
|
|
|
|
return false;
|
|
},
|
|
});
|
|
|
|
return results;
|
|
}
|
|
|
|
public intersectObject(
|
|
obj: THREE.Object3D,
|
|
options: CircularFrustumIntersectionOptions = {},
|
|
): HitResult[] {
|
|
const results: HitResult[] = [];
|
|
|
|
obj.traverseVisible((object) => {
|
|
if (options.filter && !options.filter(object))
|
|
return;
|
|
if (!(object instanceof THREE.Mesh))
|
|
return;
|
|
|
|
results.push(
|
|
...this.intersectMesh(object, !!options.findAll)
|
|
.flatMap((i) => this.intersectionToHitResult(i)),
|
|
);
|
|
});
|
|
|
|
// sort closest first
|
|
results.sort((a, b) => a.intersection.depth - b.intersection.depth);
|
|
return results;
|
|
}
|
|
|
|
private intersectionToHitResult(intersection: Intersection): HitResult[] {
|
|
const faceId = intersection.object.userData.faceId;
|
|
|
|
const results: HitResult[] = [{
|
|
kind: 'face',
|
|
id: faceId,
|
|
faceId,
|
|
intersection: {
|
|
...intersection,
|
|
triHit: undefined,
|
|
},
|
|
}];
|
|
if (intersection.triHit?.kind === 'edge') {
|
|
results.unshift({
|
|
kind: 'edge',
|
|
id: intersection.triHit?.id,
|
|
faceId,
|
|
intersection: {
|
|
...intersection,
|
|
triHit: undefined,
|
|
},
|
|
});
|
|
}
|
|
if (intersection.triHit?.kind === 'vertex') {
|
|
results.unshift({
|
|
kind: 'vertex',
|
|
id: intersection.triHit?.id,
|
|
faceId,
|
|
intersection: {
|
|
...intersection,
|
|
triHit: undefined,
|
|
},
|
|
});
|
|
}
|
|
return results;
|
|
}
|
|
} |