498 lines
19 KiB
TypeScript
498 lines
19 KiB
TypeScript
import yaml from 'yaml';
|
|
import * as THREE from 'three';
|
|
import { CONTAINED, ExtendedTriangle, INTERSECTED, NOT_INTERSECTED } from 'three-mesh-bvh';
|
|
import { CircularFrustum } from './circularFrustum';
|
|
import type { Id } from '../types';
|
|
import type { MeshDto } from '../backend/dto';
|
|
import { clamp } from '../utils/math';
|
|
|
|
export type TriangleVertexHitDetail = {
|
|
kind: 'vertex',
|
|
index: 0 | 1 | 2,
|
|
pt: THREE.Vector3,
|
|
}
|
|
export type TriangleEdgeHitDetail = {
|
|
kind: 'edge',
|
|
index: 0 | 1 | 2, // edge 0=AB, 1=BC, 2=CA
|
|
ptIndexA: 0 | 1 | 2,
|
|
ptIndexB: 0 | 1 | 2,
|
|
ptA: THREE.Vector3,
|
|
ptB: THREE.Vector3,
|
|
}
|
|
export type TriangleFaceHitDetail = {
|
|
kind: 'face',
|
|
}
|
|
|
|
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
|
|
radialDistanceAbsolute: number, // perpendicular distance from frustum axis
|
|
radialDistance: number, // radialDistanceAbsolute normalized (0..1) to frustum radius at depth
|
|
triangle: { a: THREE.Vector3, b: THREE.Vector3, c: THREE.Vector3 },
|
|
details: TriangleHitDetail,
|
|
visibility: Visibility,
|
|
triangleVertexIds: [Id, Id, Id],
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
function closestPointOnEdgeToRay(
|
|
start: THREE.Vector3,
|
|
end: THREE.Vector3,
|
|
ray: THREE.Ray,
|
|
): THREE.Vector3 {
|
|
const edgeDir = end.clone().sub(start);
|
|
const edgeLen = end.clone().sub(start).length();
|
|
|
|
const toA = start.clone().sub(ray.origin);
|
|
const axisDotEdge = ray.direction.dot(edgeDir);
|
|
const denom = 1 - axisDotEdge * axisDotEdge;
|
|
|
|
let t: number;
|
|
if (Math.abs(denom) > 1e-10)
|
|
t = (ray.direction.dot(toA) * axisDotEdge - toA.dot(edgeDir)) / denom;
|
|
else
|
|
t = 0; // edge is parallel to axis ray — any point works, pick closest endpoint
|
|
|
|
return start.clone().addScaledVector(edgeDir, clamp(t, 0, edgeLen) / edgeLen);
|
|
}
|
|
|
|
function triangleDetailsByFrustum(
|
|
tri: THREE.Triangle,
|
|
localFrustum: CircularFrustum,
|
|
): TriangleHitDetail[] {
|
|
const results: TriangleHitDetail[] = [{ kind: 'face' }];
|
|
|
|
const verts: [THREE.Vector3, 0 | 1 | 2][] = [
|
|
[tri.a, 0],
|
|
[tri.b, 1],
|
|
[tri.c, 2],
|
|
];
|
|
const edges: [THREE.Vector3, THREE.Vector3, 0 | 1 | 2, 0 | 1 | 2, 0 | 1 | 2][] = [
|
|
[tri.a, tri.b, 0, 0, 1],
|
|
[tri.b, tri.c, 1, 1, 2],
|
|
[tri.c, tri.a, 2, 2, 0],
|
|
];
|
|
|
|
// A vertex is "in the frustum" if it passes the cone test
|
|
const vertexInFrustum = verts.map(([v]) =>
|
|
CircularFrustumIntersection.pointAxialDepth(v, localFrustum) !== 'NOT_INTERSECTED'
|
|
);
|
|
|
|
// Promote to vertex hits
|
|
for (const [v, idx] of verts) {
|
|
if (vertexInFrustum[idx]) {
|
|
results.unshift({ kind: 'vertex', index: idx, pt: v });
|
|
}
|
|
}
|
|
|
|
// Promote to edge hits: an edge is hit if ANY point along it falls inside the frustum.
|
|
// We sample: the two endpoints, the closest point to the axis ray, and the closest to the apex.
|
|
for (const [a, b, edgeIdx, ptIndexA, ptIndexB] of edges) {
|
|
if (vertexInFrustum[ptIndexA] || vertexInFrustum[ptIndexB]) {
|
|
// At least one endpoint inside — edge is hit
|
|
results.unshift({ kind: 'edge', index: edgeIdx, ptIndexA, ptIndexB, ptA: a, ptB: b });
|
|
continue;
|
|
}
|
|
|
|
// Check closest point on edge to frustum axis
|
|
const closestToAxis = closestPointOnEdgeToRay(a, b, localFrustum.ray);
|
|
if (CircularFrustumIntersection.pointAxialDepth(closestToAxis, localFrustum) !== 'NOT_INTERSECTED') {
|
|
results.unshift({ kind: 'edge', index: edgeIdx, ptIndexA, ptIndexB, ptA: a, ptB: b });
|
|
continue;
|
|
}
|
|
|
|
// Check closest point on edge to apex
|
|
const edge = b.clone().sub(a);
|
|
const toA = a.clone().sub(localFrustum.apex);
|
|
const tApex = clamp(-toA.dot(edge) / edge.lengthSq(), 0, 1);
|
|
const closestToApex = a.clone().addScaledVector(edge, tApex);
|
|
if (CircularFrustumIntersection.pointAxialDepth(closestToApex, localFrustum) !== 'NOT_INTERSECTED') {
|
|
results.unshift({ kind: 'edge', index: edgeIdx, ptIndexA, ptIndexB, ptA: a, ptB: b });
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
// distance from point to frustum axis where it is the closest
|
|
private static distanceToPoint(point: THREE.Vector3, frustum: CircularFrustum): number {
|
|
const toPoint = point.clone().sub(frustum.apex);
|
|
const axial = toPoint.dot(frustum.axisNormalized);
|
|
return toPoint.addScaledVector(frustum.axisNormalized, -axial).length();
|
|
}
|
|
|
|
private distanceToPoint(point: THREE.Vector3): number {
|
|
return CircularFrustumIntersection.distanceToPoint(point, this.frustum);
|
|
}
|
|
|
|
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 as MeshDto).loop[vertexIndex].vertex;
|
|
}
|
|
|
|
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();
|
|
}
|
|
};
|
|
|
|
function getHitClosestPoint(
|
|
triangle: THREE.Triangle,
|
|
details: TriangleHitDetail,
|
|
faceClosestPoint: THREE.Vector3,
|
|
): THREE.Vector3 {
|
|
switch (details.kind) {
|
|
case 'face':
|
|
return faceClosestPoint;
|
|
case 'edge':
|
|
return closestPointOnEdgeToRay(details.ptA, details.ptB, worldFrustum.ray);
|
|
case 'vertex':
|
|
return [triangle.a, triangle.b, triangle.c][details.index];
|
|
}
|
|
}
|
|
|
|
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 triangleVertexIds = 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 closestContained = new THREE.Vector3();
|
|
tri.closestPointToPoint(localFrustum.apex, closestContained);
|
|
const worldPoint = closestContained.clone().applyMatrix4(mesh.matrixWorld);
|
|
const depth = worldFrustum.axisNormalized.dot(worldPoint.clone().sub(worldFrustum.apex));
|
|
results.push(
|
|
...triangleDetailsByFrustum(tri, localFrustum)
|
|
.map((details) => {
|
|
const closestPoint = getHitClosestPoint(tri, details, worldPoint);
|
|
const radialDistanceAbsolute = CircularFrustumIntersection.distanceToPoint(closestPoint, worldFrustum);
|
|
return {
|
|
object: mesh,
|
|
point: closestPoint,
|
|
depth,
|
|
radialDistanceAbsolute,
|
|
radialDistance: radialDistanceAbsolute / (depth * Math.tan(worldFrustum.halfAngle)),
|
|
triangle: tri,
|
|
details,
|
|
visibility,
|
|
triangleVertexIds,
|
|
};
|
|
}),
|
|
);
|
|
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 pointOnEdge = closestPointOnEdgeToRay(a, b, localFrustum.ray);
|
|
|
|
// Closest point on edge segment to the axis ray
|
|
tryBestPoint(pointOnEdge, bestPoint);
|
|
|
|
// Closest point on edge to the apex itself
|
|
const toA = a.clone().sub(localFrustum.apex);
|
|
const edge = b.clone().sub(a);
|
|
const tApex = clamp(-toA.dot(edge) / edge.lengthSq(), 0, 1);
|
|
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));
|
|
results.push(
|
|
...triangleDetailsByFrustum(tri, localFrustum)
|
|
.map((details) => {
|
|
const closestPoint = getHitClosestPoint(tri, details, worldPoint);
|
|
const radialDistanceAbsolute = CircularFrustumIntersection.distanceToPoint(closestPoint, worldFrustum);
|
|
return {
|
|
object: mesh,
|
|
point: closestPoint,
|
|
depth: worldDepth,
|
|
radialDistanceAbsolute,
|
|
radialDistance: radialDistanceAbsolute / (worldDepth * Math.tan(worldFrustum.halfAngle)),
|
|
triangle: tri,
|
|
details,
|
|
visibility,
|
|
triangleVertexIds,
|
|
};
|
|
}),
|
|
);
|
|
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)
|
|
.map((i) => this.intersectionToHitResult(i))
|
|
.filter((i) => !!i),
|
|
);
|
|
});
|
|
|
|
// sort closest first
|
|
results.sort((a, b) => a.intersection.depth - b.intersection.depth);
|
|
return results;
|
|
}
|
|
|
|
private intersectionToHitResult(intersection: Intersection): HitResult | undefined {
|
|
const userData = intersection.object.userData as MeshDto;
|
|
const faceId = userData.faceId;
|
|
const loop = userData.loop;
|
|
|
|
function vertexId(index: number) {
|
|
return intersection.triangleVertexIds[index];
|
|
}
|
|
|
|
switch (intersection.details.kind) {
|
|
case 'face':
|
|
return {
|
|
kind: 'face',
|
|
id: faceId,
|
|
faceId,
|
|
intersection,
|
|
};
|
|
case 'edge':
|
|
const triHit = intersection.details;
|
|
const edge = loop.find((v) => (v.vertex === vertexId(triHit.ptIndexA)) && (v.vertex2 === vertexId(triHit.ptIndexB)))?.edge;
|
|
return edge // undefined for edges created by tesselation like diagonals, etc.
|
|
? {
|
|
kind: 'edge',
|
|
id: edge,
|
|
faceId,
|
|
intersection,
|
|
}
|
|
: undefined;
|
|
case 'vertex':
|
|
return {
|
|
kind: 'vertex',
|
|
id: vertexId(intersection.details.index),
|
|
faceId,
|
|
intersection,
|
|
};
|
|
}
|
|
}
|
|
} |