// Vector Range: a wireframe vector display. Phosphor line mountains at the left and right thirds,
// a perspective ground grid creeping toward the viewer, a small crescent. Green structure on black.
// The beam keeps retracing the ridges like a radar tube's phosphor: an amber flash at the head, a long green tail decaying behind it.
// Amber is used for the beam and the moon only. A wide, faint glow lifts the middle of the tube, where the text sits.
// Pure string building, no imports, the same string on every call.
const WIDTH = 1600
const HEIGHT = 1000
const HORIZON = 745
/** The grid's vanishing point sits under the right-hand cards, not under the prompt box. */
const VANISH_X = 1230
const SKY_TOP = '#030a08'
const SKY_LOW = '#071a15'
const GROUND_FAR = '#051210'
const GROUND_NEAR = '#030a08'
const HOT = '#9ff0dc'
const WARM = '#3fb89a'
const COLD = '#237a68'
const AMBER = '#ffb454'
const MOON_X = 1268
const MOON_Y = 306
const MOON_RADIUS = 30
/** A repeatable number in 0..1 from two integers, so every build draws the same range. */
function hashUnit(index: number, salt: number): number {
let value = (Math.imul(index, 374761393) + Math.imul(salt, 668265263)) | 0
value = Math.imul(value ^ (value >>> 13), 1274126177)
value ^= value >>> 16
return (value >>> 0) / 4294967296
}
function round(value: number): number {
return Math.round(value * 10) / 10
}
/** A smooth bump: 1 at the centre, 0 at halfWidth away and beyond. */
function lobe(x: number, centre: number, halfWidth: number): number {
const distance = Math.abs(x - centre) / halfWidth
if (distance >= 1) return 0
const inner = 1 - distance * distance
return inner * inner
}
/** A line drawn three times, widest and faintest first. That is the whole glow; no filter. */
function glowLine(d: string, colour: string, width: number, opacity: number): string {
return (
`` +
`` +
``
)
}
/** The beam's trace: a short amber head with a halo, and three longer, fainter green tails behind it, all ending at the head. */
type TracePart = { name: string; length: number; width: number; opacity: number; colour: string }
/** The longest tail; the beam must run this far past the ridge's end before it rests. */
const LONGEST_TAIL = 0.42
const TRACE_PARTS: TracePart[] = [
{ name: 'tailLong', length: LONGEST_TAIL, width: 1.8, opacity: 0.4, colour: HOT },
{ name: 'tailMiddle', length: 0.24, width: 2, opacity: 0.6, colour: HOT },
{ name: 'tailShort', length: 0.12, width: 2.2, opacity: 0.85, colour: '#d6f2b0' },
{ name: 'halo', length: 0.07, width: 10, opacity: 0.2, colour: AMBER },
{ name: 'head', length: 0.07, width: 2.6, opacity: 1, colour: AMBER },
]
const TRACE_TRAVEL = 1 + LONGEST_TAIL
/** Where the head sits along the ridge when motion is switched off. */
const TRACE_REST_AT = 0.62
/** Four beams share one cycle: each runs for a quarter of it while the other three rest. */
const TRACE_CYCLE_SECONDS = 120
function trace(d: string, seconds: number, delay: number, shownAtRest: boolean): string {
// With motion switched off only one beam is left on the picture, caught mid-ridge; the others are parked past their ends.
return TRACE_PARTS.map(
part =>
``,
).join('')
}
/** Keyframes for one trace part: its head runs from the path's start to past its end (so the tail leaves too), then rests
* for the other three quarters of the cycle, which is when the other beams run. */
function traceKeyframes(): string {
return TRACE_PARTS.map(part => {
const start = part.length
const end = round((part.length - TRACE_TRAVEL) * 1000) / 1000
return `@keyframes ${part.name}{0%{stroke-dashoffset:${start}}25%,100%{stroke-dashoffset:${end}}}`
}).join('')
}
type MassifLayer = {
salt: number
step: number
maximumHeight: number
leftCentre: number
leftHalfWidth: number
leftScale: number
rightCentre: number
rightHalfWidth: number
fallLineAbove: number
fallLineOpacity: number
colour: string
width: number
opacity: number
dots: boolean
traceDelays: number[]
restBeamSide: number
seconds: number
delay: number
reach: number
}
type RidgeVertex = { x: number; height: number; summit: boolean }
/** A massif: tall at one or both edge thirds, sinking to nothing toward the middle so the reading column stays calm. */
function massif(layer: MassifLayer): string {
const vertices: RidgeVertex[] = []
let index = 0
for (let x = -260; x <= WIDTH + 260; x += layer.step) {
const jitteredX = x + (hashUnit(index, layer.salt) - 0.5) * layer.step * 0.5
const envelope =
lobe(jitteredX, layer.leftCentre, layer.leftHalfWidth) * layer.leftScale +
lobe(jitteredX, layer.rightCentre, layer.rightHalfWidth)
const saddle = index % 2 === 1 ? 0.6 : 1
const roughness = 0.55 + 0.45 * hashUnit(index, layer.salt + 7)
const height = envelope * layer.maximumHeight * saddle * roughness
vertices.push({ x: round(jitteredX), height: round(height < 6 ? 0 : height), summit: index % 2 === 0 })
index += 1
}
const top = vertices.map(vertex => `${vertex.x} ${round(HORIZON - vertex.height)}`)
// The cover is painted with the sky itself, so a nearer ridge hides the lines of the ridges behind it.
const cover = `M${top.join('L')}L${WIDTH + 400} ${HORIZON}L-400 ${HORIZON}Z`
// The ridge line is drawn only where there is a ridge; flat stretches are left to the horizon.
let ridge = ''
let penDown = false
vertices.forEach((vertex, position) => {
const next = vertices[position + 1]
const flat = vertex.height === 0 && (!next || next.height === 0)
if (flat && !penDown) return
ridge += `${penDown ? 'L' : 'M'}${top[position] ?? ''}`
penDown = !flat
})
// The beam only retraces what can be seen: the same ridge, cut a little outside the frame.
let traced = ''
penDown = false
vertices.forEach((vertex, position) => {
const next = vertices[position + 1]
const flat = vertex.height === 0 && (!next || next.height === 0)
const outside = vertex.x < -90 || vertex.x > WIDTH + 90
if (outside || (flat && !penDown)) {
penDown = false
return
}
traced += `${penDown ? 'L' : 'M'}${top[position] ?? ''}`
penDown = !flat
})
// One fall line per summit: down to a shoulder, then on to the foot. Nothing crosses anything.
let fallLines = ''
let dots = ''
let litFaces = ''
vertices.forEach((vertex, position) => {
if (!vertex.summit || vertex.height < layer.fallLineAbove) return
// A spur leans well off the vertical, or it looks like a tent pole.
const side = hashUnit(position, layer.salt + 13) < 0.5 ? -1 : 1
const lean = side * (0.55 + 0.4 * hashUnit(position, layer.salt + 19)) * layer.step
const shoulderX = round(vertex.x + lean * 0.5)
const shoulderY = round(HORIZON - vertex.height * (0.38 + 0.2 * hashUnit(position, layer.salt + 17)))
const footX = round(vertex.x + lean * 1.25)
const summitPoint = top[position] ?? ''
fallLines += `M${summitPoint}L${shoulderX} ${shoulderY}L${footX} ${HORIZON}`
dots += `M${summitPoint}h0`
// The face between the spur and the next saddle toward the moon catches a little light, so a peak has form.
const saddle = vertices[position + 1]
if (saddle) {
const faceFoot = Math.min(footX, saddle.x)
litFaces += `M${summitPoint}L${top[position + 1] ?? ''}L${faceFoot} ${HORIZON}L${Math.min(shoulderX, saddle.x)} ${shoulderY}Z`
}
})
return (
`` +
`` +
`` +
`` +
glowLine(ridge, layer.colour, layer.width, layer.opacity) +
// A vector beam dwells at the corners, so the summits are a little brighter than the lines between them.
(layer.dots ? `` : '') +
// Dashes restart on every subpath, so each side of the massif gets its own beam, and they take turns.
traced
.split('M')
.filter(part => part.length > 0)
.map((part, side) => trace(`M${part}`, TRACE_CYCLE_SECONDS, layer.traceDelays[side] ?? 0, side === layer.restBeamSide))
.join('') +
``
)
}
/**
* The far range: low rolling hills along the whole horizon. It repeats exactly every FAR_TILE units,
* so it can drift one way for ever. It is the only thing that crosses the reading column, so it is low and faint there.
*/
const FAR_STEP = 78
const FAR_COUNT = 21
const FAR_TILE = FAR_STEP * FAR_COUNT
function farRange(): string {
let ridge = ''
for (let index = 0; index * FAR_STEP <= WIDTH + FAR_TILE + 200; index += 1) {
const wrapped = index % FAR_COUNT
const x = round(-100 + index * FAR_STEP + (hashUnit(wrapped, 3) - 0.5) * FAR_STEP * 0.4)
const height = round((wrapped % 2 === 1 ? 8 : 20) + hashUnit(wrapped, 5) * 20)
ridge += `${index === 0 ? 'M' : 'L'}${x} ${HORIZON - height}`
}
const cover = `${ridge}L${WIDTH + FAR_TILE + 300} ${HORIZON}L-100 ${HORIZON}Z`
return (
`` +
`` +
// One flat faint stroke: a paint that fades across the column would have to stand still while the ridge drifts under it.
`` +
``
)
}
/** Depth of the nearest cross line, and the count of cross lines travelling between the horizon and the viewer. */
const NEAR_DEPTH = 1.5
const CROSS_LINES = 11
const CREEP_SECONDS = 12
function crossLineY(depth: number): number {
return round(HORIZON + ((HEIGHT - HORIZON) * NEAR_DEPTH) / depth)
}
/**
* Every cross line walks the same road, from the horizon out past the bottom edge, one grid cell every CREEP_SECONDS.
* One set of keyframes holds the road; each line starts further along it. Perspective makes the road nonlinear,
* so the keyframes carry a stop per cell, and extra stops close to the viewer where it bends most.
*/
function creepKeyframes(): string {
const stops: string[] = []
const total = CROSS_LINES + 1
for (let step = 0; step <= total * 4; step += 1) {
const travelled = step / 4
const depth = NEAR_DEPTH + CROSS_LINES - travelled
const nearViewer = depth < 5
if (!nearViewer && step % 4 !== 0) continue
stops.push(`${round((travelled / total) * 100)}%{transform:translateY(${crossLineY(depth)}px)}`)
}
return `@keyframes creep{${stops.join('')}}`
}
function groundGrid(): string {
let rays = ''
// The feet straddle the vanishing point so that no ray is a plain vertical, and the shallowest rays are left out: they only stack up.
for (let foot = -2200; foot <= 3400; foot += 400) {
rays += `M${VANISH_X} ${HORIZON}L${round(VANISH_X + foot * 1.2)} ${round(HORIZON + (HEIGHT - HORIZON) * 1.2)}`
}
let crossLines = ''
for (let line = 0; line <= CROSS_LINES; line += 1) {
const y = crossLineY(NEAR_DEPTH + line)
const delay = (CROSS_LINES - line) * CREEP_SECONDS
crossLines += ``
}
return (
`` +
`` +
crossLines +
`` +
``
)
}
/** The moon: a proper crescent of two arcs at one weight, small, in the beam's amber. */
function crescent(centreX: number, centreY: number, radius: number): string {
const topX = round(centreX - radius * 0.5)
const topY = round(centreY - radius * 0.866)
const bottomX = round(centreX + radius * 0.866)
const bottomY = round(centreY + radius * 0.5)
const inner = round(radius * 1.55)
const outline = `M${topX} ${topY}A${radius} ${radius} 0 0 1 ${bottomX} ${bottomY}A${inner} ${inner} 0 0 0 ${topX} ${topY}Z`
return glowLine(outline, AMBER, 1.25, 0.5)
}
/** Stars in the left and right thirds only, three tiers; about one in four breathes, each on its own period. */
function stars(): string {
let small = ''
let large = ''
let middling = ''
let breathing = ''
for (let index = 0; index < 64; index += 1) {
const onLeft = index % 2 === 0
const x = round(onLeft ? 20 + hashUnit(index, 101) * 400 : 1205 + hashUnit(index, 101) * 375)
const y = round(16 + hashUnit(index, 103) * 470)
// No star may shine through the moon.
if (Math.hypot(x - MOON_X, y - MOON_Y) < MOON_RADIUS + 60) continue
if (index % 4 === 1) {
breathing += ``
} else if (index % 3 === 0) {
large += `M${x} ${y}h0`
} else if (index % 3 === 2) {
middling += `M${x} ${y}h0`
} else {
small += `M${x} ${y}h0`
}
}
return (
`` +
`` +
`${breathing}`
)
}
/**
* A stroke paint that is full at the edges and `low` across the reading column, with long soft shoulders.
* It does a mask's job without a mask: a mask over anything that moves makes the browser repaint an offscreen layer every frame.
*/
function fadeStroke(name: string, colour: string, low: number): string {
const half = round((1 + low) / 2)
return (
`` +
`` +
`` +
``
)
}
export function vectorRangeSvg(): string {
const style = `
path{fill:none;stroke-linejoin:round}
.cover{fill:url(#sky);stroke:none}
.lit{fill:#9fe8cf;fill-opacity:.055;stroke:none}
.sway{animation:sway 120s ease-in-out infinite alternate}
.drift{animation:drift 520s linear infinite}
.cross{animation:creep ${(CROSS_LINES + 1) * CREEP_SECONDS}s linear infinite}
.trace{animation-timing-function:cubic-bezier(.3,.1,.7,.9);animation-iteration-count:infinite}
${TRACE_PARTS.map(part => `.${part.name}{animation-name:${part.name}}`).join('')}
.breathe{stroke-opacity:.55;animation:breathe 9s ease-in-out infinite}
@keyframes sway{from{transform:translateX(calc(var(--reach) * -1))}to{transform:translateX(var(--reach))}}
@keyframes drift{from{transform:translateX(0)}to{transform:translateX(-${FAR_TILE}px)}}
${traceKeyframes()}
@keyframes breathe{0%,100%{stroke-opacity:.12}50%{stroke-opacity:1}}
${creepKeyframes()}
@media (prefers-reduced-motion: reduce){*{animation:none!important}}`
const defs = `
${fadeStroke('floorStroke', '#2f9a82', 0.13)}${fadeStroke('horizonStroke', WARM, 0.12)}`
const middleMassif = massif({
salt: 11, step: 62, maximumHeight: 345,
leftCentre: 350, leftHalfWidth: 200, leftScale: 0.4, rightCentre: 1420, rightHalfWidth: 330,
fallLineAbove: 60, fallLineOpacity: 0.7, colour: WARM, width: 1.2, opacity: 0.36, dots: false,
traceDelays: [42, 102], restBeamSide: -1, seconds: 120, delay: 70, reach: 15,
})
const nearMassif = massif({
salt: 29, step: 50, maximumHeight: 200,
leftCentre: 60, leftHalfWidth: 340, leftScale: 0.6, rightCentre: 1590, rightHalfWidth: 310,
fallLineAbove: 40, fallLineOpacity: 0.6, colour: HOT, width: 1.3, opacity: 0.5, dots: true,
traceDelays: [72, 12], restBeamSide: 1, seconds: 120, delay: 5, reach: 40,
})
const horizonLine = glowLine(`M-100 ${HORIZON}H1700`, 'url(#horizonStroke)', 1, 0.28)
return ``
}