From 933969b7da10d99e6c90390d9b90cdffb38fb1f6 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 11 Nov 2026 17:58:40 -0800 Subject: [PATCH] GPU icons draw offsets, anchors, rotations, fades, display ranges and clamped heights Each row reads its extras from a float texture by instance (texelFetch on gl_InstanceID), so the 16 vertex attributes hold: pixel offset, vertical anchor, screen rotation and aligned axis (turned as billboards turn), fadeByDistance, displayRange, and a ground mode with the heights under its segment's two ends. Clamped rows are sampled after a frame draws, budgeted across the port's sets (terrain first, then the drawn surface), and again when the globe's tiles finish loading. WebGL 1 still refuses these; GPU sets still refuse clustering. The stub picks icons offset, anchored, turned and clamped to its ellipsoid, and draw.motion.look checks each on a moving icon. --- docs/RENDERER-CONTRACT.md | 12 ++ src/data/iconSet.js | 181 ++++++++++++++++++ src/render/cesium/draw.js | 6 + src/render/cesium/gpuIcons.js | 245 +++++++++++++++++++++++-- src/render/cesium/gpuIcons.test.mjs | 149 ++++++++++++++- src/render/cesium/harness.js | 1 + src/render/cesium/iconSetPrimitive.js | 133 +++++++++++++- src/render/conformance/checks/ports.js | 138 ++++++++++++++ src/render/stub/index.js | 56 +++++- 9 files changed, 892 insertions(+), 29 deletions(-) diff --git a/docs/RENDERER-CONTRACT.md b/docs/RENDERER-CONTRACT.md index 36b9e3594..16bbe94a8 100644 --- a/docs/RENDERER-CONTRACT.md +++ b/docs/RENDERER-CONTRACT.md @@ -179,6 +179,18 @@ members' billboards; a set on the GPU (`columns`, or moving, receding, proxy-picked or level-of-detail icons) refuses clustering. The check `draw.icons.cluster` draws a cluster, picks it, and parts it by moving in. +Icon sets on the Cesium GPU path draw what its billboards draw but +clustering: pixel offsets, `bottom` and `top` anchors, screen and axis +rotations (turned as Cesium's billboards turn), `fadeByDistance`, +`displayRange`, and `clampGround` / `relativeGround` heights. Each row reads +these from a float texture by instance, so the 16 vertex attributes hold; +WebGL 1 has no such fetch and refuses them. A clamped row stands on the +ground taken between the heights under its segment's two ends, sampled after +a frame draws, 256 ends a frame across the port's sets: loaded terrain first, +then (but for `clampTo: 'terrain'`) the drawn surface, eight a frame. They are +sampled again when the globe's tiles finish loading and, clamped to more than +terrain, every 5 s. The check `draw.motion.look` draws each on a moving icon. + A set's `blend` holds for every kind of set: omitted, opaque parts draw opaque with depth writes and translucent ones blend without; `opaque` draws every item opaque, its alpha ignored, with depth writes; `translucent` blends diff --git a/src/data/iconSet.js b/src/data/iconSet.js index d09886587..28e437e8e 100644 --- a/src/data/iconSet.js +++ b/src/data/iconSet.js @@ -46,6 +46,42 @@ const PROXY_WIDTH = 13; const PROXY_HEIGHT = 14; const DEPTH_TEST_DISTANCE = 15; +/** + * Floats per row of extras, as `ICON_EXTRA_TEXELS` RGBA texels the renderer + * reads by instance: the screen offset, anchor and rotation; the fade by + * distance; the aligned axis and display range; the ground mode and the + * ground heights under the segment's two ends, and those ends. All zero (the + * default) is none of them. + */ +export const ICON_EXTRA_TEXELS = 6; +export const EXTRA_STRIDE = ICON_EXTRA_TEXELS * 4; + +const OFFSET_X = 0; +const OFFSET_Y = 1; +const ANCHOR = 2; +const ROTATION = 3; +const FADE_NEAR = 4; +const FADE_NEAR_VALUE = 5; +const FADE_FAR = 6; +const FADE_FAR_VALUE = 7; +const AXIS_X = 8; +const AXIS_Y = 9; +const AXIS_Z = 10; +const RANGE_NEAR = 11; +const RANGE_FAR = 12; +const GROUND_MODE = 13; +const GROUND_FROM = 14; +const GROUND_TO = 15; +const SPAN_FROM = 16; +const SPAN_TO = 20; + +/** Ground modes of a row's extras. */ +export const ICON_GROUND_NONE = 0; +/** Drawn on the ground under it. */ +export const ICON_GROUND_CLAMP = 1; +/** Drawn its height above the ground under it. */ +export const ICON_GROUND_RELATIVE = 2; + /** * A depth-test distance at or past this draws over depth at any distance * (Infinity, which a float column does not carry through every GPU). @@ -164,6 +200,7 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { let segments = new Float32Array(capacity * SEGMENT_STRIDE); let style = new Float32Array(capacity * STYLE_STRIDE); let colors = new Uint8Array(capacity * 4); + let extras = new Float32Array(capacity * EXTRA_STRIDE); // CPU only: until when (seconds since the epoch) the row's segment holds. let expires = new Float64Array(capacity); let count = 0; @@ -176,6 +213,7 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { segments: new DirtyRows(capacity), style: new DirtyRows(capacity), colors: new DirtyRows(capacity), + extras: new DirtyRows(capacity), }, show: true, /** Called with a row's renderer handle when the row goes away. */ @@ -196,6 +234,9 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { get colors() { return colors; }, + get extras() { + return extras; + }, get epoch() { return epochTime; }, @@ -270,6 +311,7 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { style[o + IMAGE_NEAR] = -1; style[o + DEPTH_TEST_DISTANCE] = ICON_ALWAYS_OVER_DEPTH; colors.fill(255, row * 4, row * 4 + 4); + extras.fill(0, row * EXTRA_STRIDE, (row + 1) * EXTRA_STRIDE); expires[row] = -Infinity; markRow(row); return row; @@ -294,6 +336,11 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { (last + 1) * STYLE_STRIDE, ); colors.copyWithin(row * 4, last * 4, last * 4 + 4); + extras.copyWithin( + row * EXTRA_STRIDE, + last * EXTRA_STRIDE, + (last + 1) * EXTRA_STRIDE, + ); expires[row] = expires[last]; ids[row] = ids[last]; metas[row] = metas[last]; @@ -517,6 +564,129 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { return result; }, + /** + * Shift on screen by `x` right and `y` down, CSS pixels, as a billboard's + * `pixelOffset`. + */ + setOffset(row, x, y) { + writeExtra(row, OFFSET_X, x); + writeExtra(row, OFFSET_Y, y); + }, + offset(row) { + const o = row * EXTRA_STRIDE; + return { x: extras[o + OFFSET_X], y: extras[o + OFFSET_Y] }; + }, + + /** + * Which edge sits on the position: 0 the centre, 1 the bottom, -1 the + * top (a billboard's vertical origin). + */ + setAnchor(row, anchor) { + writeExtra(row, ANCHOR, anchor); + }, + anchor(row) { + return extras[row * EXTRA_STRIDE + ANCHOR]; + }, + + /** Radians counter-clockwise on screen. */ + setRotation(row, radians) { + writeExtra(row, ROTATION, radians); + }, + rotation(row) { + return extras[row * EXTRA_STRIDE + ROTATION]; + }, + + /** + * Turn the icon's up along an ECEF axis on screen, as a billboard's + * `alignedAxis` (zero: upright). + */ + setAxis(row, x, y, z) { + writeExtra(row, AXIS_X, x); + writeExtra(row, AXIS_Y, y); + writeExtra(row, AXIS_Z, z); + }, + axis(row) { + const o = row * EXTRA_STRIDE; + return { + x: extras[o + AXIS_X], + y: extras[o + AXIS_Y], + z: extras[o + AXIS_Z], + }; + }, + + /** + * Fade by camera distance, as a `{near, nearValue, far, farValue}` + * curve multiplying the alpha (unset: none); faded to nothing, the row + * is not drawn. + */ + setFade(row, curve) { + writeExtra(row, FADE_NEAR, curve?.near ?? 0); + writeExtra(row, FADE_NEAR_VALUE, curve?.nearValue ?? 0); + writeExtra(row, FADE_FAR, curve?.far ?? 0); + writeExtra(row, FADE_FAR_VALUE, curve?.farValue ?? 0); + }, + fade(row) { + const o = row * EXTRA_STRIDE; + return { + near: extras[o + FADE_NEAR], + nearValue: extras[o + FADE_NEAR_VALUE], + far: extras[o + FADE_FAR], + farValue: extras[o + FADE_FAR_VALUE], + }; + }, + + /** + * Drawn only at camera distances from `near` to `far`, metres; a `far` + * not past `near` is no range. + */ + setDisplayRange(row, near, far) { + writeExtra(row, RANGE_NEAR, near); + writeExtra(row, RANGE_FAR, Math.min(far, ICON_ALWAYS_OVER_DEPTH)); + }, + displayRange(row) { + const o = row * EXTRA_STRIDE; + return [extras[o + RANGE_NEAR], extras[o + RANGE_FAR]]; + }, + + /** + * Draw on the ground (`ICON_GROUND_CLAMP`) or above it + * (`ICON_GROUND_RELATIVE`) along the segment from `from` to `to` (ECEF, + * its two ends), the ground taken between the heights at those ends + * (`setGroundHeights`); `ICON_GROUND_NONE` where it is. + */ + setGround(row, mode, from, to) { + writeExtra(row, GROUND_MODE, mode); + for (const [at, p] of [ + [SPAN_FROM, from], + [SPAN_TO, to], + ]) { + writeExtra(row, at, p?.x ?? 0); + writeExtra(row, at + 1, p?.y ?? 0); + writeExtra(row, at + 2, p?.z ?? 0); + } + }, + groundMode(row) { + return extras[row * EXTRA_STRIDE + GROUND_MODE]; + }, + /** The ground's ellipsoid heights under the segment's ends, metres. */ + setGroundHeights(row, from, to) { + writeExtra(row, GROUND_FROM, from); + writeExtra(row, GROUND_TO, to); + }, + /** The segment's ends the ground is taken along, ECEF. */ + groundSpan(row) { + const o = row * EXTRA_STRIDE; + return [SPAN_FROM, SPAN_TO].map((at) => ({ + x: extras[o + at], + y: extras[o + at + 1], + z: extras[o + at + 2], + })); + }, + groundHeights(row) { + const o = row * EXTRA_STRIDE; + return [extras[o + GROUND_FROM], extras[o + GROUND_TO]]; + }, + /** Where the row is at `tau` (seconds since the epoch). */ position(row, tau, result) { return segmentPosition(segments, row, tau, result); @@ -554,6 +724,14 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { set.dirty.segments.mark(row); set.dirty.style.mark(row); set.dirty.colors.mark(row); + set.dirty.extras.mark(row); + } + + function writeExtra(row, field, value) { + const o = row * EXTRA_STRIDE + field; + if (extras[o] === Math.fround(value)) return; + extras[o] = value; + set.dirty.extras.mark(row); } function writeStyle(row, field, value) { @@ -579,11 +757,14 @@ export function createIconSet({ capacity = 1024, epoch } = {}) { st.set(style); const c = new Uint8Array(next * 4); c.set(colors); + const x = new Float32Array(next * EXTRA_STRIDE); + x.set(extras); const e = new Float64Array(next); e.set(expires); segments = s; style = st; colors = c; + extras = x; expires = e; capacity = next; set.generation++; diff --git a/src/render/cesium/draw.js b/src/render/cesium/draw.js index c1123fccb..aeda2f944 100644 --- a/src/render/cesium/draw.js +++ b/src/render/cesium/draw.js @@ -5159,6 +5159,12 @@ export function createCesiumDraw({ afterRender() { watchClamp(); swapReady(); + // Clamped GPU icons take the ground under their segments. + const budget = gpu.groundBudget(); + let grounded = false; + for (const record of sets.values()) + if (record.gpu?.ground(budget)) grounded = true; + if (grounded) requestRender(); for (const record of sets.values()) if (record.kind === 'lines') try { diff --git a/src/render/cesium/gpuIcons.js b/src/render/cesium/gpuIcons.js index 0dee1f58d..3f6a552e6 100644 --- a/src/render/cesium/gpuIcons.js +++ b/src/render/cesium/gpuIcons.js @@ -11,9 +11,19 @@ * * What these sets draw as billboards do not: an icon set becomes one when * an item first needs it (or it first takes columns), and stays one. They - * refuse loudly what billboards draw and they do not: clamped heights, - * `fadeByDistance`, `displayRange`, pixel offsets, anchors other than the - * centre, axis and screen rotations, and clustering. Their + * draw what billboards draw but clustering, which they refuse loudly; on + * WebGL 1 they also refuse what each row reads from its extras texture + * there is none of: clamped heights, `fadeByDistance`, `displayRange`, pixel + * offsets, anchors other than the centre, and axis and screen rotations. + * + * A clamped row (`clampGround`, `relativeGround`) stands on the ground + * taken between the heights under its segment's two ends, sampled after a + * frame draws, `GROUND_SAMPLES_PER_FRAME` ends a frame across the port's + * sets: the loaded terrain first, then, but for `clampTo: 'terrain'`, the + * drawn surface (`SURFACE_SAMPLES_PER_FRAME`, where the scene samples it). + * An end with no height yet stands on the ellipsoid. Every end is sampled + * again once the globe's tiles finish loading, and, clamped to more than + * terrain, every `GROUND_REFRESH_MS`. Their * images (URLs, SVG, blobs, keyed canvases and atlas slots of those) * are rasterised square into the icon atlas every GPU icon set shares, and * refused when it has no room left for them: an SVG at its own size (its @@ -37,6 +47,9 @@ import * as Cesium from 'cesium'; import { createIconSet, ICON_CULL_LIFT, + ICON_GROUND_CLAMP, + ICON_GROUND_NONE, + ICON_GROUND_RELATIVE, ICON_RECEDES, ICON_ROTATES, } from '../../data/iconSet.js'; @@ -54,6 +67,7 @@ import { motionEndsAt, } from '../motion/iconMotion.js'; import { blobUrl, toCartesian } from './common.js'; +import { heightsFor } from './heights.js'; /** The capabilities GPU icon sets bring. */ export const GPU_ICON_CAPABILITIES = Object.freeze([ @@ -68,6 +82,24 @@ const nonZero = (v) => /** Whether a curve is one (as the billboards read it). */ const isCurve = (curve) => Boolean(curve) && curve.far > curve.near; +/** Whether a `displayRange` shows anything: `[near, far)` is not empty. */ +const displayable = (range) => !range || range[1] > range[0]; + +/** An anchor as the row's vertical origin: the edge on the position. */ +const ANCHORS = { center: 0, bottom: 1, top: -1 }; + +const GROUND_MODES = { + clampGround: ICON_GROUND_CLAMP, + relativeGround: ICON_GROUND_RELATIVE, +}; + +/** Segment ends sampled for their ground after a frame, across the sets. */ +export const GROUND_SAMPLES_PER_FRAME = 256; +/** Of those, how many also sample the drawn surface (each draws a view). */ +export const SURFACE_SAMPLES_PER_FRAME = 8; +/** How often rows clamped to more than terrain are sampled again, ms. */ +export const GROUND_REFRESH_MS = 5000; + /** * An image's atlas key: a URL itself, SVG as a data URL, a blob as its * object URL, a generated canvas by its key; else null. @@ -209,16 +241,19 @@ export function createGpuIcons({ const refuse = (what) => { throw new Error(`the Cesium renderer's GPU icons have no ${what}`); }; - if (item.height !== undefined && item.height !== 'absolute') - refuse('clamped heights'); - if (item.fadeByDistance) refuse('fadeByDistance'); - if (item.displayRange) refuse('displayRange'); - if (nonZero(item.pixelOffset)) refuse('pixelOffset'); - if (item.anchor !== undefined && item.anchor !== 'center') - refuse('anchors but the centre'); - if (item.rotationMode === 'axis') refuse('axis rotation'); - if (item.rotationMode === 'screen' && (item.rotation ?? 0) !== 0) - refuse('screen rotation'); + // What a row reads from its extras texture, which WebGL 1 has not. + if (scene.context?.webgl2 === false) { + if (item.height !== undefined && item.height !== 'absolute') + refuse('clamped heights on WebGL 1'); + if (item.fadeByDistance) refuse('fadeByDistance on WebGL 1'); + if (item.displayRange) refuse('displayRange on WebGL 1'); + if (nonZero(item.pixelOffset)) refuse('pixelOffset on WebGL 1'); + if (item.anchor !== undefined && item.anchor !== 'center') + refuse('anchors but the centre on WebGL 1'); + if (item.rotationMode === 'axis') refuse('axis rotation on WebGL 1'); + if (item.rotationMode === 'screen' && (item.rotation ?? 0) !== 0) + refuse('screen rotation on WebGL 1'); + } for (const given of [item.image, item.imageLod?.near]) { // An atlas slot as what it holds now (none yet draws once it does). const image = @@ -392,7 +427,47 @@ export function createGpuIcons({ item.pickProxy?.size?.[1] ?? 0, ); set.setDepthTestDistance(row, item.disableDepthTest ?? 0); - set.setShown(row, item.show !== false); + // An empty range shows it nowhere. + set.setShown(row, item.show !== false && displayable(item.displayRange)); + writeExtras(row, item); + writeSegment(row, item, added, motion); + writeGround(row, item); + } + + /** A row's offset, anchor, rotation, fade and display range. */ + function writeExtras(row, item) { + set.setOffset(row, item.pixelOffset?.x ?? 0, item.pixelOffset?.y ?? 0); + set.setAnchor(row, ANCHORS[item.anchor] ?? 0); + set.setRotation( + row, + item.rotationMode === 'screen' ? (item.rotation ?? 0) : 0, + ); + // Its up along the axis, as a billboard's; one of zero length + // stands upright. + const { + x = 0, + y = 0, + z = 0, + } = (item.rotationMode === 'axis' && item.alignedAxis) || {}; + const length = Math.hypot(x, y, z); + if (length > 0) set.setAxis(row, x / length, y / length, z / length); + else set.setAxis(row, 0, 0, 0); + set.setFade( + row, + isCurve(item.fadeByDistance) ? item.fadeByDistance : undefined, + ); + const range = + item.displayRange && displayable(item.displayRange) + ? item.displayRange + : [0, 0]; + set.setDisplayRange(row, range[0], range[1]); + } + + /** + * Write a row's segment and course easing, unless `motion` is false + * (and the row not new) or its motion is as written. + */ + function writeSegment(row, item, added, motion) { if (!motion && !added) return; // A write moving it as it already moves (a restyle, a focus change) // keeps its segment and course easing as they are. @@ -428,6 +503,83 @@ export function createGpuIcons({ if (end > movingUntil) movingUntil = end; } + // Clamped rows by id, those whose ground is still to sample, those never + // sampled yet, and what each row's ground was last written from. + const grounded = new Set(); + const groundQueue = new Set(); + const unsampled = new Set(); + const groundKeys = new Map(); + let groundRefreshedAt = -Infinity; + let tilesWereLoaded = false; + + /** The two ends of a row's segment, ECEF. */ + function spanOf(row, item) { + const motion = can('motionSegments') ? item.motion : undefined; + let t0 = 0; + let t1 = 0; + if (motion?.kind === 'lerp') { + t0 = tauOf(motion.t0); + t1 = Math.max(tauOf(motion.t1), t0 + LERP_STEP_MS / 1000); + } else if (motion?.kind === 'arc') { + const t = tauOf(motion.t0); + t0 = t + motion.minDtS; + t1 = t + motion.maxDtS; + } + return [ + set.position(row, t0, { x: 0, y: 0, z: 0 }), + set.position(row, t1, { x: 0, y: 0, z: 0 }), + ]; + } + + /** A row's ground mode and segment ends, queued to sample when new. */ + function writeGround(row, item) { + const mode = GROUND_MODES[item.height] ?? ICON_GROUND_NONE; + if (mode === ICON_GROUND_NONE) { + if (grounded.delete(item.id)) { + set.setGround(row, ICON_GROUND_NONE); + set.setGroundHeights(row, 0, 0); + groundQueue.delete(item.id); + unsampled.delete(item.id); + groundKeys.delete(item.id); + } + return; + } + const [from, to] = spanOf(row, item); + const key = `${mode}|${from.x}|${from.y}|${from.z}|${to.x}|${to.y}|${to.z}`; + if (!grounded.has(item.id)) { + grounded.add(item.id); + unsampled.add(item.id); + } + if (groundKeys.get(item.id) === key) return; + groundKeys.set(item.id, key); + set.setGround(row, mode, from, to); + groundQueue.add(item.id); + } + + const groundAt = new Cesium.Cartesian3(); + const groundCarto = new Cesium.Cartographic(); + /** + * The ground's height under `p`: the drawn surface when `surface` + * (else, or where it has none, the loaded terrain, but for `clampTo: + * 'tiles'`); null where neither answers. + */ + function groundHeight(p, surface) { + Cesium.Cartesian3.fromElements(p.x, p.y, p.z, groundAt); + const carto = Cesium.Cartographic.fromCartesian( + groundAt, + undefined, + groundCarto, + ); + if (!carto) return null; + const heights = heightsFor(scene); + if (surface) { + const h = heights.now(carto); + if (h !== null) return h; + } + if (spec.clampTo === 'tiles') return null; + return heights.now(carto, { against: 'terrain' }); + } + /** Bring the rows in line with every item. */ function sync() { fresh = false; @@ -535,6 +687,63 @@ export function createGpuIcons({ if (fresh) return sync(); for (const item of drawing) writeRow(item); }, + /** + * After a frame: sample the ground under clamped rows' segment ends, + * from `budget` (`{ends, surface}`, spent). Whether a row's ground + * changed. + */ + ground(budget) { + if (grounded.size === 0) return false; + const loaded = scene.globe?.tilesLoaded === true; + const now = Date.now(); + const clampTo = spec.clampTo ?? 'both'; + if ( + (loaded && !tilesWereLoaded) || + (clampTo !== 'terrain' && + now - groundRefreshedAt >= GROUND_REFRESH_MS) + ) { + for (const id of grounded) groundQueue.add(id); + groundRefreshedAt = now; + } + tilesWereLoaded = loaded; + const surface = + clampTo !== 'terrain' && scene.sampleHeightSupported === true; + let changed = false; + const later = []; + for (const id of groundQueue) { + if (budget.ends < 1) break; + const row = set.row(id); + if (row < 0 || set.groundMode(row) === ICON_GROUND_NONE) { + groundQueue.delete(id); + grounded.delete(id); + unsampled.delete(id); + groundKeys.delete(id); + continue; + } + const [from, to] = set.groundSpan(row); + const same = from.x === to.x && from.y === to.y && from.z === to.z; + const ends = same ? 1 : 2; + if (budget.ends < ends) continue; + const drawn = surface && budget.surface >= ends; + // Out of surface samples: a row never sampled takes the terrain + // for now and waits; the rest wait as they stand. + if (surface && !drawn && !unsampled.has(id)) continue; + groundQueue.delete(id); + if (surface && !drawn) later.push(id); + budget.ends -= ends; + if (drawn) budget.surface -= ends; + const h0 = groundHeight(from, drawn) ?? 0; + const h1 = same ? h0 : (groundHeight(to, drawn) ?? 0); + unsampled.delete(id); + const [g0, g1] = set.groundHeights(row); + if (g0 !== Math.fround(h0) || g1 !== Math.fround(h1)) { + set.setGroundHeights(row, h0, h1); + changed = true; + } + } + for (const id of later) groundQueue.add(id); + return changed; + }, /** Whether a live-clock row is still moving: frames should keep coming. */ animating() { if (spec.motionClock?.kind === 'scene' || spec.show === false) @@ -557,5 +766,11 @@ export function createGpuIcons({ }; } - return { wants, check, attach }; + /** A frame's ground samples, shared by the port's GPU icon sets. */ + const groundBudget = () => ({ + ends: GROUND_SAMPLES_PER_FRAME, + surface: SURFACE_SAMPLES_PER_FRAME, + }); + + return { wants, check, attach, groundBudget }; } diff --git a/src/render/cesium/gpuIcons.test.mjs b/src/render/cesium/gpuIcons.test.mjs index e1b81398d..6852cdf5a 100644 --- a/src/render/cesium/gpuIcons.test.mjs +++ b/src/render/cesium/gpuIcons.test.mjs @@ -318,8 +318,9 @@ test('without motionSegments, motion is ignored: billboards at the item’s plac assert.equal(set.setColumns, undefined, 'no columns either'); }); -test('GPU icon sets refuse what they cannot draw, changing nothing', () => { - const { part, draw } = drawOver(); +test('on WebGL 1, GPU icon sets refuse what their rows read from extras, changing nothing', () => { + const { part, draw, scene } = drawOver(); + scene.context = { webgl2: false }; const set = draw.icons({ id: 'gpu:refuse' }); set.set([icon('a', { motion: { kind: 'hold' } })]); for (const extra of [ @@ -333,7 +334,7 @@ test('GPU icon sets refuse what they cannot draw, changing nothing', () => { ]) assert.throws( () => set.upsert([icon('b', { motion: { kind: 'hold' }, ...extra })]), - /GPU icons have no/, + /GPU icons have no .* on WebGL 1/, JSON.stringify(extra), ); assert.equal(set.size(), 1); @@ -349,6 +350,148 @@ test('GPU icon sets refuse what they cannot draw, changing nothing', () => { assert.equal(billboards.size(), 1); }); +test('offsets, anchors, rotations, fades and display ranges go into a row’s extras', () => { + const { part, draw } = drawOver(); + const set = draw.icons({ id: 'gpu:extras' }); + // A billboard set holding them moves over whole. + set.set([icon('a', { anchor: 'top', pixelOffset: { x: 3, y: -4 } })]); + set.upsert([ + icon('b', { + motion: { kind: 'hold' }, + anchor: 'bottom', + rotationMode: 'screen', + rotation: 0.5, + fadeByDistance: { near: 10, nearValue: 1, far: 1e5, farValue: 0 }, + displayRange: [5, 2e6], + }), + icon('c', { + motion: { kind: 'hold' }, + rotationMode: 'axis', + alignedAxis: { x: 0, y: 0, z: 4 }, + }), + icon('d', { motion: { kind: 'hold' }, displayRange: [10, 10] }), + ]); + const { set: s } = rows(part, 'gpu:extras'); + const a = s.row('a'); + assert.deepEqual(s.offset(a), { x: 3, y: -4 }); + assert.equal(s.anchor(a), -1, 'top'); + const b = s.row('b'); + assert.equal(s.anchor(b), 1, 'bottom'); + assert.equal(s.rotation(b), 0.5); + assert.deepEqual(s.fade(b), { + near: 10, + nearValue: 1, + far: 1e5, + farValue: 0, + }); + assert.deepEqual(s.displayRange(b), [5, 2e6]); + assert.equal(s.shown(b), true); + const c = s.row('c'); + assert.deepEqual(s.axis(c), { x: 0, y: 0, z: 1 }, 'normalised'); + assert.equal(s.rotation(c), 0); + assert.equal(s.shown(s.row('d')), false, 'an empty range shows nowhere'); + // Dropped in place, each goes back to none. + set.upsert([icon('b', { motion: { kind: 'hold' } })]); + assert.equal(s.anchor(b), 0); + assert.equal(s.rotation(b), 0); + assert.deepEqual(s.fade(b), { near: 0, nearValue: 0, far: 0, farValue: 0 }); + assert.deepEqual(s.displayRange(b), [0, 0]); + // A row moved by a removal keeps its own. + set.remove(['a']); + assert.deepEqual(s.axis(s.row('c')), { x: 0, y: 0, z: 1 }); +}); + +test('clamped rows stand on the ground sampled under their segment ends, after a frame', () => { + const { part, draw, scene } = drawOver(); + // Terrain rising 1 m a hundredth of a degree east. + const asked = []; + scene.globe = { + tilesLoaded: false, + getHeight: (carto) => { + asked.push(carto); + return Cesium.Math.toDegrees(carto.longitude) * 100; + }, + }; + const set = draw.icons({ id: 'gpu:ground', clampTo: 'terrain' }); + const from = Cesium.Cartesian3.fromDegrees(4, 52, 900); + const to = Cesium.Cartesian3.fromDegrees(5, 52, 900); + const t0 = Date.now(); + set.set([ + icon('a', { + height: 'clampGround', + motion: { kind: 'lerp', from, to, t0, t1: t0 + 1000 }, + }), + icon('b', { height: 'relativeGround', motion: { kind: 'hold' } }), + icon('c', { motion: { kind: 'hold' } }), + ]); + const { set: s } = rows(part, 'gpu:ground'); + const a = s.row('a'); + assert.deepEqual(s.groundHeights(a), [0, 0], 'none sampled while drawing'); + assert.equal(asked.length, 0); + const renders = scene.renders; + part.afterRender(); + const [g0, g1] = s.groundHeights(a); + assert.ok( + Math.abs(g0 - 400) < 1e-3 && Math.abs(g1 - 500) < 1e-3, + `${g0} ${g1}`, + ); + const [span0, span1] = s.groundSpan(a); + assert.ok(distance(span0, from) < 1 && distance(span1, to) < 1, 'its ends'); + assert.equal(s.groundMode(a), 1, 'clamped'); + assert.equal(s.groundMode(s.row('b')), 2, 'relative'); + assert.equal(s.groundMode(s.row('c')), 0, 'absolute'); + assert.ok(scene.renders > renders, 'a frame for the new ground'); + // Sampled once: no samples in frames after. + const once = asked.length; + assert.equal(once, 3, 'two ends, and a held row’s one'); + part.afterRender(); + assert.equal(asked.length, once); + // Its tiles loaded: sampled again. + scene.globe.tilesLoaded = true; + part.afterRender(); + assert.equal(asked.length, once * 2); + // Unclamped, it drops its ground. + set.upsert([icon('a', { motion: { kind: 'hold' } })]); + assert.equal(s.groundMode(a), 0); + assert.deepEqual(s.groundHeights(a), [0, 0]); +}); + +test('ground samples are budgeted across frames, the drawn surface the fewest', () => { + const { part, draw, scene } = drawOver(); + let terrain = 0; + let surface = 0; + scene.globe = { getHeight: () => (terrain++, 10) }; + scene.sampleHeightSupported = true; + scene.sampleHeight = () => (surface++, 30); + const set = draw.icons({ id: 'gpu:budget' }); + const n = 300; + set.set( + Array.from({ length: n }, (_, i) => + icon(`r${i}`, { height: 'clampGround', motion: { kind: 'hold' } }), + ), + ); + const { set: s } = rows(part, 'gpu:budget'); + part.afterRender(); + assert.ok( + terrain + surface <= 256, + `at most 256 a frame: ${terrain} ${surface}`, + ); + assert.equal(surface, 8, 'eight on the drawn surface'); + const heights = () => + [...Array(n).keys()].map((i) => s.groundHeights(s.row(`r${i}`))[0]); + assert.equal(heights().filter((h) => h === 30).length, 8); + assert.equal( + heights().filter((h) => h === 10).length, + 248, + 'the rest on terrain for now', + ); + for (let i = 0; i < 60; i++) part.afterRender(); + assert.ok( + heights().every((h) => h === 30), + 'in time all on the drawn surface', + ); +}); + test('GPU icon sets refuse clustering, changing nothing', () => { const { part, draw } = drawOver(); const cluster = { pixelRange: 10, minimumSize: 2 }; diff --git a/src/render/cesium/harness.js b/src/render/cesium/harness.js index bf93f78d2..e762b8721 100644 --- a/src/render/cesium/harness.js +++ b/src/render/cesium/harness.js @@ -66,6 +66,7 @@ export const CESIUM_CHECKS = new Set([ 'draw.motion.arc', 'draw.motion.climb', 'draw.motion.live', + 'draw.motion.look', 'draw.motion.shared', 'draw.pick', 'draw.points.update', diff --git a/src/render/cesium/iconSetPrimitive.js b/src/render/cesium/iconSetPrimitive.js index 8d22f9a12..c754dbb2e 100644 --- a/src/render/cesium/iconSetPrimitive.js +++ b/src/render/cesium/iconSetPrimitive.js @@ -12,13 +12,22 @@ * `{ id, meta, primitive }` (`primitive.show` hides that one row, as drillPick expects). * Rows flagged to recede also take the aircraft limb recession, composed with focus. * + * On WebGL 2 each row also reads its extras ({@link module:iconSet}'s + * `extras`) from a float texture by instance: a screen offset and anchor, a + * screen rotation or aligned axis (turned as a billboard's), a fade and a + * display range by distance, and the ground it is clamped to or stands + * above, taken between the heights under its segment's two ends. On WebGL 1 + * the extras are not drawn (the draw port refuses rows that need them). + * * This module is the one place the icon sets touch Cesium's renderer internals. */ import * as Cesium from 'cesium'; import { ICON_SEGMENT_GLSL, SEGMENT_STRIDE } from '../../data/iconSegment.js'; import { + EXTRA_STRIDE, ICON_CULL_HEIGHT_M, ICON_CULL_LIFT, + ICON_EXTRA_TEXELS, STYLE_STRIDE, } from '../../data/iconSet.js'; import { @@ -74,6 +83,9 @@ uniform vec3 u_recessionFloors; // scale, alpha, combined alpha uniform vec4 u_slots[ICON_SLOTS]; // ICON_SLOTS: as many as the context addresses uniform float u_cull; // 1: hide rows past the ellipsoid's horizon uniform float u_pickPass; // 1 while drawing for a pick +#ifdef ICON_EXTRAS +uniform highp sampler2D u_extras; // ICON_EXTRA_TEXELS texels a row, ICON_EXTRA_ROWS rows a line +#endif out vec2 v_uv; out vec4 v_color; @@ -119,6 +131,32 @@ void main() { vec3 rte = iconSegmentPosition(seg0, seg1, seg2, seg3, seg4, seg5, u_tau); vec3 world = u_cameraPosition + rte; +#ifdef ICON_EXTRAS + ivec2 cell = ivec2( + (gl_InstanceID % ICON_EXTRA_ROWS) * ICON_EXTRA_TEXELS, + gl_InstanceID / ICON_EXTRA_ROWS + ); + vec4 extra0 = texelFetch(u_extras, cell, 0); // offset x, y (CSS px, y down), anchor, rotation + vec4 extra1 = texelFetch(u_extras, cell + ivec2(1, 0), 0); // fade by distance + vec4 extra2 = texelFetch(u_extras, cell + ivec2(2, 0), 0); // aligned axis, range near + vec4 extra3 = texelFetch(u_extras, cell + ivec2(3, 0), 0); // range far, ground mode, heights + if (extra3.y > 0.5) { + // The ground under it: between the heights under its segment's ends, + // by how far along from one to the other it is. + vec3 from = texelFetch(u_extras, cell + ivec2(4, 0), 0).xyz; + vec3 span = texelFetch(u_extras, cell + ivec2(5, 0), 0).xyz - from; + float spanSq = dot(span, span); + float along = spanSq > 0.0 ? clamp(dot(world - from, span) / spanSq, 0.0, 1.0) : 0.0; + float ground = mix(extra3.z, extra3.w, along); + vec3 up = czm_geodeticSurfaceNormal(world, vec3(0.0), czm_ellipsoidInverseRadii * czm_ellipsoidInverseRadii); + float radius = length(world); + float height = radius * (1.0 - 1.0 / length(world * czm_ellipsoidInverseRadii)); + // Clamped: on the ground; relative: its height above it. + vec3 lift = up * (extra3.y < 1.5 ? ground - height : ground); + rte += lift; + world += lift; + } +#endif vec3 cullPoint = iconFlag(flags, ${ICON_CULL_LIFT.toFixed(1)}) ? iconCullPoint(world) : world; if (u_cull > 0.5 && occludedByEllipsoid(cullPoint)) return; @@ -127,6 +165,13 @@ void main() { iconAnchorClip = czm_projection * positionEC; float distanceSq = dot(positionEC.xyz, positionEC.xyz); +#ifdef ICON_EXTRAS + // Out of its display range, or faded to nothing: not drawn. + if (extra3.x > extra2.w && + (distanceSq < extra2.w * extra2.w || distanceSq > extra3.x * extra3.x)) return; + float fade = extra1.z > extra1.x ? czm_nearFarScalar(extra1, distanceSq) : 1.0; + if (fade <= 0.0) return; +#endif float distanceScale = style2.z > 0.0 ? czm_nearFarScalar(style2, distanceSq) : 1.0; float scale = style0.z; float alpha = style0.w; @@ -154,6 +199,13 @@ void main() { if (rect.z <= 0.0) return; // image not loaded yet vec2 halfSize = style0.xy * (scale * distanceScale * 0.5) * corner; + vec2 shift = vec2(0.0); +#ifdef ICON_EXTRAS + alpha *= fade; + // Its anchor edge on the position, as a billboard's vertical origin, then + // its offset: neither turns with it. + shift = vec2(0.0, extra0.z) * abs(halfSize) + vec2(extra0.x, -extra0.y); +#endif // A pick proxy: picked over the larger of it and the drawn icon. if (u_pickPass > 0.5 && style3.y > 0.0 && style3.z > 0.0) { halfSize = max(abs(halfSize), style3.yz * 0.5) * corner; @@ -178,7 +230,22 @@ void main() { halfSize = mat2(c, s, -s, c) * halfSize; } } - positionEC.xy += halfSize * czm_metersPerPixel(positionEC); +#ifdef ICON_EXTRAS + else { + // Turned as a billboard is: its rotation, and its up along the axis. + float angle = extra0.w; + vec4 axis = czm_modelView3D * vec4(extra2.xyz, 0.0); + float axisSq = axis.x * axis.x + axis.y * axis.y; + if (dot(extra2.xyz, extra2.xyz) > 0.0 && axisSq > 0.0) + angle += sign(-axis.x) * acos(sign(axis.y) * axis.y * axis.y / axisSq); + if (angle != 0.0) { + float c = cos(angle); + float s = sin(angle); + halfSize = mat2(c, s, -s, c) * halfSize; + } + } +#endif + positionEC.xy += (halfSize + shift) * czm_metersPerPixel(positionEC); gl_Position = czm_projection * positionEC; #ifdef LOG_DEPTH @@ -240,6 +307,9 @@ export function contextIconSlots(context) { return addressableIconSlots(Cesium.ContextLimits.maximumVertexUniformVectors); } +/** Rows a line of the extras texture holds. */ +export const ICON_EXTRA_ROWS = 256; + const SEGMENT_BYTES = SEGMENT_STRIDE * 4; const STYLE_BYTES = STYLE_STRIDE * 4; const EARTH_BOUNDS = new Cesium.BoundingSphere( @@ -278,6 +348,9 @@ export class IconSetPrimitive { this._programs = null; this._commands = null; this._texture = null; + // The rows' extras, on WebGL 2 (null until allocated, and on WebGL 1). + this._extras = null; + this._extrasLine = null; this._atlasVersion = -1; this._slots = Array.from( { length: MAX_ICON_SLOTS }, @@ -307,6 +380,7 @@ export class IconSetPrimitive { u_recessionFloors: () => primitive._recessionFloors, u_slots: () => primitive._slotUniform, u_atlas: () => primitive._texture, + u_extras: () => primitive._extras, u_cull: () => (primitive._cull() ? 1 : 0), u_pickPass: () => primitive._pickPass, }; @@ -456,6 +530,19 @@ export class IconSetPrimitive { indexBuffer: buffers.index, }); this._pickColors = new Uint8Array(capacity * 4); + if (context.webgl2) { + const lines = Math.ceil(capacity / ICON_EXTRA_ROWS); + this._extras = new Cesium.Texture({ + context, + width: ICON_EXTRA_ROWS * ICON_EXTRA_TEXELS, + height: lines, + pixelFormat: Cesium.PixelFormat.RGBA, + pixelDatatype: Cesium.PixelDatatype.FLOAT, + flipY: false, + sampler: Cesium.Sampler.NEAREST, + }); + this._extrasLine = new Float32Array(ICON_EXTRA_ROWS * EXTRA_STRIDE); + } this._generation = set.generation; for (const rows of Object.values(set.dirty)) rows.markAll(); if (this._commands) @@ -489,9 +576,40 @@ export class IconSetPrimitive { set.colors.subarray(from * 4, (to + 1) * 4), from * 4, ); + if (this._extras) { + // Whole lines of the texture: a run's first to its last. + const lineFloats = ICON_EXTRA_ROWS * EXTRA_STRIDE; + const source = set.extras; + let done = -1; + for (const [from, to] of set.dirty.extras.runs(count)) { + for ( + let line = Math.max(done + 1, Math.floor(from / ICON_EXTRA_ROWS)); + line <= Math.floor(to / ICON_EXTRA_ROWS); + line++ + ) { + const start = line * lineFloats; + let view = source.subarray(start, start + lineFloats); + if (view.length < lineFloats) { + this._extrasLine.fill(0); + this._extrasLine.set(view); + view = this._extrasLine; + } + this._extras.copyFrom({ + source: { + width: ICON_EXTRA_ROWS * ICON_EXTRA_TEXELS, + height: 1, + arrayBufferView: view, + }, + yOffset: line, + }); + done = line; + } + } + } segments.clear(); style.clear(); colors.clear(); + set.dirty.extras.clear(); } _writePick(context, row) { @@ -595,7 +713,16 @@ export class IconSetPrimitive { Cesium.ShaderProgram.fromCache({ context, vertexShaderSource: new Cesium.ShaderSource({ - defines: [`ICON_SLOTS ${this._slotCount}`], + defines: [ + `ICON_SLOTS ${this._slotCount}`, + ...(this._extras + ? [ + 'ICON_EXTRAS', + `ICON_EXTRA_ROWS ${ICON_EXTRA_ROWS}`, + `ICON_EXTRA_TEXELS ${ICON_EXTRA_TEXELS}`, + ] + : []), + ], sources: [VERTEX_SHADER], }), fragmentShaderSource: new Cesium.ShaderSource({ @@ -644,6 +771,8 @@ export class IconSetPrimitive { _destroyBuffers() { this._vertexArray?.destroy(); // destroys its buffers too this._vertexArray = null; + this._extras?.destroy(); + this._extras = null; this._buffers = null; } diff --git a/src/render/conformance/checks/ports.js b/src/render/conformance/checks/ports.js index e7727a91c..c221d4566 100644 --- a/src/render/conformance/checks/ports.js +++ b/src/render/conformance/checks/ports.js @@ -1922,6 +1922,144 @@ export function portChecks() { set.dispose(); }, ), + check( + 'draw.motion.look', + 'moving icons draw offset, anchored, turned, clamped, faded and ranged as icons do', + async (h, r) => { + await overAustin(h, r); + const set = r.draw.icons({ + id: 'conf:motion-look', + motionClock: { kind: 'scene' }, + }); + const pos = h.toEcef({ ...AUSTIN, height: 0 }); + const icon = (extra = {}) => ({ + id: 'one', + pos, + image: DOT, + size: [16, 16], + motion: { kind: 'hold' }, + ...extra, + }); + const mine = (x, y) => + r.query + .drillPick(x, y) + .some((hit) => hit.set === 'conf:motion-look' && hit.id === 'one'); + const show = async (extra) => { + set.set([icon(extra)]); + await drawn(h, r); + await settled(r); + await drawn(h, r); + }; + await show(); + const s = r.query.project(pos); + ok(s, 'the icon projects'); + ok(mine(s.x, s.y), 'drawn where it is'); + await show({ pixelOffset: { x: 40, y: 0 } }); + ok(mine(s.x + 40, s.y) && !mine(s.x, s.y), 'offset 40 px right'); + await show({ anchor: 'bottom', size: [16, 48] }); + ok( + mine(s.x, s.y - 36) && !mine(s.x, s.y + 12), + 'anchored by its bottom: above its position', + ); + // Long and flat; a quarter turn stands it up. + await show({ size: [64, 8] }); + ok(mine(s.x + 24, s.y) && !mine(s.x, s.y + 24), 'unturned, it is wide'); + await show({ + size: [64, 8], + rotationMode: 'screen', + rotation: Math.PI / 2, + }); + ok( + mine(s.x, s.y + 24) && !mine(s.x + 24, s.y), + 'a quarter turn on screen stands it up', + ); + // Looking north, an up along east turns it a quarter clockwise. + const east = h.toEcef({ + lon: AUSTIN.lon + 0.01, + lat: AUSTIN.lat, + height: 0, + }); + await show({ + size: [64, 8], + rotationMode: 'axis', + alignedAxis: { + x: east.x - pos.x, + y: east.y - pos.y, + z: east.z - pos.z, + }, + }); + ok( + mine(s.x, s.y + 24) && !mine(s.x + 24, s.y), + 'its up along east stands it up', + ); + // Off to the east and a kilometre up, clamped: on the ground there. + const where = { lon: AUSTIN.lon + 0.004, lat: AUSTIN.lat }; + const ground = r.query.project(h.toEcef({ ...where, height: 0 })); + const raised = r.query.project(h.toEcef({ ...where, height: 1000 })); + ok( + ground && raised && Math.abs(raised.x - ground.x) > 30, + 'apart on screen', + ); + await show({ pos: h.toEcef({ ...where, height: 1000 }) }); + ok( + mine(raised.x, raised.y) && !mine(ground.x, ground.y), + 'absolute: up high', + ); + await show({ + pos: h.toEcef({ ...where, height: 1000 }), + height: 'clampGround', + }); + ok( + mine(ground.x, ground.y) && !mine(raised.x, raised.y), + 'clamped: on the ground', + ); + // Moving between two such points, clamped: on the ground between. + const lerpAt = (a, b, t) => ({ + x: a.x + (b.x - a.x) * t, + y: a.y + (b.y - a.y) * t, + z: a.z + (b.z - a.z) * t, + }); + const west = { lon: AUSTIN.lon - 0.004, lat: AUSTIN.lat }; + const from = h.toEcef({ ...where, height: 1000 }); + const to = h.toEcef({ ...west, height: 1000 }); + const t0 = r.frame.time(); + r.frame.setTime(t0 + 2500); + await show({ + pos: from, + height: 'clampGround', + motion: { kind: 'lerp', from, to, t0, t1: t0 + 10000 }, + }); + const quarter = r.query.project( + lerpAt( + h.toEcef({ ...where, height: 0 }), + h.toEcef({ ...west, height: 0 }), + 0.25, + ), + ); + const up = r.query.project(lerpAt(from, to, 0.25)); + ok( + mine(quarter.x, quarter.y) && !mine(up.x, up.y), + 'moving clamped: on the ground under it', + ); + // The eye is 2 km off. + const curve = (value) => ({ + near: 1e4, + nearValue: value, + far: 1e7, + farValue: value, + }); + await show({ fadeByDistance: curve(0) }); + ok(!mine(s.x, s.y), 'faded out by distance: not drawn'); + await show({ fadeByDistance: curve(1) }); + ok(mine(s.x, s.y), 'not faded: drawn'); + await show({ displayRange: [0, 100] }); + ok(!mine(s.x, s.y), 'out of its display range: not drawn'); + await show({ displayRange: [0, 1e6] }); + ok(mine(s.x, s.y), 'in its display range: drawn'); + set.dispose(); + }, + { capability: 'motionSegments' }, + ), check( 'draw.lines.depthFail', 'a line dashed behind the surface draws, moves in place and changes back to solid', diff --git a/src/render/stub/index.js b/src/render/stub/index.js index d250c367e..72d3f1666 100644 --- a/src/render/stub/index.js +++ b/src/render/stub/index.js @@ -754,13 +754,17 @@ export function createStubRenderer(options = {}) { function itemPosition(set, item, aheadMs = 0) { if (!item.pos) return null; const base = toEcef(item.pos); - if ( - set.kind === 'icons' && - item.motion && - capabilities.has('motionSegments') - ) - return motionPosition(item.motion, base, motionTime(set) + aheadMs); - return base; + const p = + set.kind === 'icons' && item.motion && capabilities.has('motionSegments') + ? motionPosition(item.motion, base, motionTime(set) + aheadMs) + : base; + // The stub's ground is the ellipsoid: a clamped icon stands on it, one + // relative to it where it is. + if (set.kind !== 'icons' || item.height !== 'clampGround' || !p) return p; + const c = toCartographicRadians(p); + return c + ? toEcef({ lon: toDegrees(c.lon), lat: toDegrees(c.lat), height: 0 }) + : p; } /** @@ -995,9 +999,43 @@ export function createStubRenderer(options = {}) { : 1; // Scaled to nothing, it is not drawn. if (scale <= 0) continue; + // An icon's centre: its anchor edge on the position (as drawn, not + // as a proxy), then its pixel offset (y down). + let cx = s.x; + let cy = s.y; + let dx = x - cx; + let dy = y - cy; + if (set.kind === 'icons') { + const lift = { bottom: 1, top: -1 }[item.anchor] ?? 0; + cx += item.pixelOffset?.x ?? 0; + cy += + (item.pixelOffset?.y ?? 0) - + (lift * (item.size?.[1] ?? 0) * scale) / 2; + dx = x - cx; + dy = y - cy; + // Turned counter-clockwise on screen (its up along the axis + // as projected there): the pick turned back. + let turn = item.rotationMode === 'screen' ? (item.rotation ?? 0) : 0; + const axis = item.rotationMode === 'axis' ? item.alignedAxis : null; + if ( + axis && + magnitude(vec(axis.x ?? 0, axis.y ?? 0, axis.z ?? 0)) > 0 + ) { + const tip = project( + add(p, normalize(vec(axis.x ?? 0, axis.y ?? 0, axis.z ?? 0))), + ); + if (tip && (tip.x !== s.x || tip.y !== s.y)) + turn = Math.atan2(-(tip.x - s.x), -(tip.y - s.y)); + } + if (turn !== 0) { + const c = Math.cos(turn); + const n = Math.sin(turn); + [dx, dy] = [dx * c - dy * n, dx * n + dy * c]; + } + } if ( - Math.abs(s.x - x) <= (size[0] * scale) / 2 + halfW && - Math.abs(s.y - y) <= (size[1] * scale) / 2 + halfH + Math.abs(dx) <= (size[0] * scale) / 2 + halfW && + Math.abs(dy) <= (size[1] * scale) / 2 + halfH ) hits.push({ set: setId,