refactor(launches): Cesium rendering behind a renderer interface

This commit is contained in:
German Khokhlov committed 2026-10-23 00:32:10 +04:00
1 parent 1839d62160
commit 4baefeb8f9
31 files changed
+1202 -420

No files matched your search

+235
View File
@@ -0,0 +1,235 @@
// Ported from CesiumJS 1.138 (Apache-2.0) — BoundingSphere.js subset.
// Exact mission framing: Ritter/box fit and the union of two spheres.
import * as Cartesian3 from './cartesian3.js';
import { Check } from './check.js';
import { DEBUG } from './debug.js';
const defined = (value) => value !== null && value !== undefined;
export function create(center = Cartesian3.ZERO, radius = 0) {
return { center: Cartesian3.clone(center), radius };
}
export function clone(sphere, result = create()) {
Cartesian3.clone(sphere.center, result.center);
result.radius = sphere.radius;
return result;
}
const fromPointsXMin = Cartesian3.create();
const fromPointsYMin = Cartesian3.create();
const fromPointsZMin = Cartesian3.create();
const fromPointsXMax = Cartesian3.create();
const fromPointsYMax = Cartesian3.create();
const fromPointsZMax = Cartesian3.create();
const fromPointsCurrentPos = Cartesian3.create();
const fromPointsScratch = Cartesian3.create();
const fromPointsRitterCenter = Cartesian3.create();
const fromPointsMinBoxPt = Cartesian3.create();
const fromPointsMaxBoxPt = Cartesian3.create();
const fromPointsNaiveCenterScratch = Cartesian3.create();
const unionScratch = Cartesian3.create();
const unionScratchCenter = Cartesian3.create();
export function fromPoints(positions, result) {
if (!defined(result)) {
result = create();
}
if (!defined(positions) || positions.length === 0) {
result.center = Cartesian3.clone(Cartesian3.ZERO, result.center);
result.radius = 0.0;
return result;
}
const currentPos = Cartesian3.clone(positions[0], fromPointsCurrentPos);
const xMin = Cartesian3.clone(currentPos, fromPointsXMin);
const yMin = Cartesian3.clone(currentPos, fromPointsYMin);
const zMin = Cartesian3.clone(currentPos, fromPointsZMin);
const xMax = Cartesian3.clone(currentPos, fromPointsXMax);
const yMax = Cartesian3.clone(currentPos, fromPointsYMax);
const zMax = Cartesian3.clone(currentPos, fromPointsZMax);
const numPositions = positions.length;
let i;
for (i = 1; i < numPositions; i++) {
Cartesian3.clone(positions[i], currentPos);
const x = currentPos.x;
const y = currentPos.y;
const z = currentPos.z;
// Store points containing the the smallest and largest components
if (x < xMin.x) {
Cartesian3.clone(currentPos, xMin);
}
if (x > xMax.x) {
Cartesian3.clone(currentPos, xMax);
}
if (y < yMin.y) {
Cartesian3.clone(currentPos, yMin);
}
if (y > yMax.y) {
Cartesian3.clone(currentPos, yMax);
}
if (z < zMin.z) {
Cartesian3.clone(currentPos, zMin);
}
if (z > zMax.z) {
Cartesian3.clone(currentPos, zMax);
}
}
// Compute x-, y-, and z-spans (Squared distances b/n each component's min. and max.).
const xSpan = Cartesian3.magnitudeSquared(
Cartesian3.subtract(xMax, xMin, fromPointsScratch),
);
const ySpan = Cartesian3.magnitudeSquared(
Cartesian3.subtract(yMax, yMin, fromPointsScratch),
);
const zSpan = Cartesian3.magnitudeSquared(
Cartesian3.subtract(zMax, zMin, fromPointsScratch),
);
// Set the diameter endpoints to the largest span.
let diameter1 = xMin;
let diameter2 = xMax;
let maxSpan = xSpan;
if (ySpan > maxSpan) {
maxSpan = ySpan;
diameter1 = yMin;
diameter2 = yMax;
}
if (zSpan > maxSpan) {
maxSpan = zSpan;
diameter1 = zMin;
diameter2 = zMax;
}
// Calculate the center of the initial sphere found by Ritter's algorithm
const ritterCenter = fromPointsRitterCenter;
ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
// Calculate the radius of the initial sphere found by Ritter's algorithm
let radiusSquared = Cartesian3.magnitudeSquared(
Cartesian3.subtract(diameter2, ritterCenter, fromPointsScratch),
);
let ritterRadius = Math.sqrt(radiusSquared);
// Find the center of the sphere found using the Naive method.
const minBoxPt = fromPointsMinBoxPt;
minBoxPt.x = xMin.x;
minBoxPt.y = yMin.y;
minBoxPt.z = zMin.z;
const maxBoxPt = fromPointsMaxBoxPt;
maxBoxPt.x = xMax.x;
maxBoxPt.y = yMax.y;
maxBoxPt.z = zMax.z;
const naiveCenter = Cartesian3.midpoint(
minBoxPt,
maxBoxPt,
fromPointsNaiveCenterScratch,
);
// Begin 2nd pass to find naive radius and modify the ritter sphere.
let naiveRadius = 0;
for (i = 0; i < numPositions; i++) {
Cartesian3.clone(positions[i], currentPos);
// Find the furthest point from the naive center to calculate the naive radius.
const r = Cartesian3.magnitude(
Cartesian3.subtract(currentPos, naiveCenter, fromPointsScratch),
);
if (r > naiveRadius) {
naiveRadius = r;
}
// Make adjustments to the Ritter Sphere to include all points.
const oldCenterToPointSquared = Cartesian3.magnitudeSquared(
Cartesian3.subtract(currentPos, ritterCenter, fromPointsScratch),
);
if (oldCenterToPointSquared > radiusSquared) {
const oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
// Calculate new radius to include the point that lies outside
ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
radiusSquared = ritterRadius * ritterRadius;
// Calculate center of new Ritter sphere
const oldToNew = oldCenterToPoint - ritterRadius;
ritterCenter.x =
(ritterRadius * ritterCenter.x + oldToNew * currentPos.x) /
oldCenterToPoint;
ritterCenter.y =
(ritterRadius * ritterCenter.y + oldToNew * currentPos.y) /
oldCenterToPoint;
ritterCenter.z =
(ritterRadius * ritterCenter.z + oldToNew * currentPos.z) /
oldCenterToPoint;
}
}
if (ritterRadius < naiveRadius) {
Cartesian3.clone(ritterCenter, result.center);
result.radius = ritterRadius;
} else {
Cartesian3.clone(naiveCenter, result.center);
result.radius = naiveRadius;
}
return result;
}
export function union(left, right, result) {
if (DEBUG) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
}
if (!defined(result)) {
result = create();
}
const leftCenter = left.center;
const leftRadius = left.radius;
const rightCenter = right.center;
const rightRadius = right.radius;
const toRightCenter = Cartesian3.subtract(
rightCenter,
leftCenter,
unionScratch,
);
const centerSeparation = Cartesian3.magnitude(toRightCenter);
if (leftRadius >= centerSeparation + rightRadius) {
// Left sphere wins.
clone(left, result);
return result;
}
if (rightRadius >= centerSeparation + leftRadius) {
// Right sphere wins.
clone(right, result);
return result;
}
// There are two tangent points, one on far side of each sphere.
const halfDistanceBetweenTangentPoints =
(leftRadius + centerSeparation + rightRadius) * 0.5;
// Compute the center point halfway between the two tangent points.
const center = Cartesian3.multiplyByScalar(
toRightCenter,
(-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation,
unionScratchCenter,
);
Cartesian3.add(center, leftCenter, center);
Cartesian3.clone(center, result.center);
result.radius = halfDistanceBetweenTangentPoints;
return result;
}