Sprites for helicopters, ground vehicles, stations and vessel types; history to live without an empty map; model parts in Cesium

Aircraft icons are one size; helicopters turn a three-frame rotor while
airborne or moving; ADS-B ground vehicles share one amber sprite and
stations/obstacles one mast; vessels get hull sprites by type and one buoy.
Going live keeps contacts until the first live answer and replaces them by
id; fast playback holds before the loaded positions end and prefetches
ahead. Cesium models move their parts from the optional model part state.
This commit is contained in:
Sameh Khamis committed 2026-11-17 15:09:54 -08:00
1 parent 624c229bc2
commit 7186f720df
97 files changed
+6586 -343

No files matched your search

+261
View File
@@ -0,0 +1,261 @@
/**
* @module render/conformance/partsModel
* @description A glTF model with moving parts, built in code for the
* conformance checks (`PARTS_MODEL_TABLE` says what its parts are). One
* mesh whose vertices carry their part index (`_PART`), its node scaled
* (by ten unless told otherwise: the mesh is in tenths of the model's
* metres), and the part table in that node's `extras`.
*/
/** Each cube face: its normal and two axes across it. */
const FACES = [
[
[1, 0, 0],
[0, 1, 0],
[0, 0, 1],
],
[
[-1, 0, 0],
[0, 0, 1],
[0, 1, 0],
],
[
[0, 1, 0],
[0, 0, 1],
[1, 0, 0],
],
[
[0, -1, 0],
[1, 0, 0],
[0, 0, 1],
],
[
[0, 0, 1],
[1, 0, 0],
[0, 1, 0],
],
[
[0, 0, -1],
[0, 1, 0],
[1, 0, 0],
],
];
/**
* Append a cube of half size `half` centred at `centre` (the model's glTF
* frame, metres) as part `part`, its vertices and normals put into the
* mesh's own frame by `toMesh`.
*/
function cube(mesh, centre, half, part, toMesh) {
for (const [n, u, v] of FACES) {
const base = mesh.positions.length / 3;
for (const [su, sv] of [
[-1, -1],
[1, -1],
[1, 1],
[-1, 1],
]) {
const p = [0, 1, 2].map(
(i) => centre[i] + half * (n[i] + su * u[i] + sv * v[i]),
);
mesh.positions.push(...toMesh.point(p));
mesh.normals.push(...toMesh.direction(n));
mesh.parts.push(part);
}
// Counter-clockwise seen from outside: u × v is the normal.
mesh.indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
}
}
/**
* The part table, in the model's glTF frame (forward −X, up +Y, right −Z):
* a 20 m cube (`body`) centred on the origin; a 10 m cube on top of it
* (`pod`) that spins about the vertical through its centre; a 6 m cube on
* top of that (`ram`) that slides forward up to 20 m; and a 6 m cube 15 m
* ahead of the body at its foot (`arm`), hinged about the vertical through
* the body's centre, turning up to 45° to the left.
*/
export const PARTS_MODEL_TABLE = Object.freeze([
{ name: 'body', kind: 'body' },
{ name: 'pod', kind: 'spin', pivot: [0, 15, 0], axis: [0, 1, 0] },
{
name: 'ram',
kind: 'slide',
pivot: [0, 23, 0],
axis: [-1, 0, 0],
limits: [0, 20],
rest: 0,
},
{
name: 'arm',
kind: 'hinge',
pivot: [0, 3, 0],
axis: [0, 1, 0],
limits: [0, 45],
rest: 0,
},
]);
/** Each part's cube: its centre (glTF frame, metres) and half size. */
const CUBES = [
[[0, 0, 0], 10],
[[0, 15, 0], 5],
[[0, 23, 0], 3],
[[-15, 3, 0], 3],
];
/**
* The model's GLB bytes. Its mesh node is scaled by `scale`, turned
* `turnDeg` about its vertical and moved by `translation`; the mesh is
* built in that node's own frame, so the model it draws is the same
* whatever the node's transform.
* @param {{scale?: number, turnDeg?: number,
* translation?: [number, number, number]}} [node]
* @returns {Uint8Array}
*/
export function partsModelGlb({
scale = 10,
turnDeg = 0,
translation = [0, 0, 0],
} = {}) {
const a = (turnDeg * Math.PI) / 180;
const c = Math.cos(a);
const sn = Math.sin(a);
// The node's turn undone: about +Y by −turnDeg.
const unturn = ([x, y, z]) => [c * x - sn * z, y, sn * x + c * z];
const toMesh = {
point: (p) =>
unturn([0, 1, 2].map((i) => p[i] - translation[i])).map((v) => v / scale),
direction: unturn,
};
const mesh = { positions: [], normals: [], parts: [], indices: [] };
CUBES.forEach(([centre, half], part) =>
cube(mesh, centre, half, part, toMesh),
);
const count = mesh.parts.length;
const positions = new Float32Array(mesh.positions);
const normals = new Float32Array(mesh.normals);
// A vertex attribute's elements sit on 4-byte boundaries.
const parts = new Uint8Array(count * 4);
mesh.parts.forEach((part, i) => (parts[i * 4] = part));
const indices = new Uint16Array(mesh.indices);
const chunks = [positions, normals, parts, indices];
const offsets = [];
let length = 0;
for (const chunk of chunks) {
offsets.push(length);
length += Math.ceil(chunk.byteLength / 4) * 4;
}
const bin = new Uint8Array(length);
chunks.forEach((chunk, i) =>
bin.set(
new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength),
offsets[i],
),
);
const min = [Infinity, Infinity, Infinity];
const max = [-Infinity, -Infinity, -Infinity];
for (let i = 0; i < positions.length; i++) {
min[i % 3] = Math.min(min[i % 3], positions[i]);
max[i % 3] = Math.max(max[i % 3], positions[i]);
}
const json = {
asset: { version: '2.0' },
scene: 0,
scenes: [{ nodes: [0] }],
nodes: [
{
name: 'parts',
mesh: 0,
scale: [scale, scale, scale],
rotation: [0, Math.sin(a / 2), 0, Math.cos(a / 2)],
translation,
extras: { parts: PARTS_MODEL_TABLE },
},
],
meshes: [
{
primitives: [
{
attributes: { POSITION: 0, NORMAL: 1, _PART: 2 },
indices: 3,
material: 0,
},
],
},
],
materials: [
{
pbrMetallicRoughness: {
baseColorFactor: [1, 1, 1, 1],
metallicFactor: 0,
roughnessFactor: 1,
},
},
],
buffers: [{ byteLength: length }],
bufferViews: [
{
buffer: 0,
byteOffset: offsets[0],
byteLength: positions.byteLength,
target: 34962,
},
{
buffer: 0,
byteOffset: offsets[1],
byteLength: normals.byteLength,
target: 34962,
},
{
buffer: 0,
byteOffset: offsets[2],
byteLength: parts.byteLength,
byteStride: 4,
target: 34962,
},
{
buffer: 0,
byteOffset: offsets[3],
byteLength: indices.byteLength,
target: 34963,
},
],
accessors: [
{
bufferView: 0,
componentType: 5126,
count,
type: 'VEC3',
min,
max,
},
{ bufferView: 1, componentType: 5126, count, type: 'VEC3' },
{ bufferView: 2, componentType: 5121, count, type: 'SCALAR' },
{
bufferView: 3,
componentType: 5123,
count: indices.length,
type: 'SCALAR',
},
],
};
let text = new TextEncoder().encode(JSON.stringify(json));
const padded = new Uint8Array(Math.ceil(text.length / 4) * 4).fill(0x20);
padded.set(text);
text = padded;
const total = 12 + 8 + text.length + 8 + bin.length;
const out = new Uint8Array(total);
const view = new DataView(out.buffer);
view.setUint32(0, 0x46546c67, true);
view.setUint32(4, 2, true);
view.setUint32(8, total, true);
view.setUint32(12, text.length, true);
view.setUint32(16, 0x4e4f534a, true);
out.set(text, 20);
const binAt = 20 + text.length;
view.setUint32(binAt, bin.length, true);
view.setUint32(binAt + 4, 0x004e4942, true);
out.set(bin, binAt + 8);
return out;
}