@bvdmitri/gyroview 0.0.0-stage → 0.9.0-cutaway.2

package/dist/packages/adapters/three/src/shaderPrograms.js

@@ -0,0 +1,68 @@
+import analysis_frag_default from "./shaders/analysis.frag.js";
+import displayConversion_default from "./shaders/displayConversion.js";
+import equirectangularRays_default from "./shaders/equirectangularRays.js";
+import fixedJoin_default from "./shaders/fixedJoin.js";
+import header_default from "./shaders/header.js";
+import lensModels_default from "./shaders/lensModels.js";
+import lensSampling_default from "./shaders/lensSampling.js";
+import lensTextures_default from "./shaders/lensTextures.js";
+import rawLenses_frag_default from "./shaders/rawLenses.frag.js";
+import rectilinearRays_default from "./shaders/rectilinearRays.js";
+import screenAreas_default from "./shaders/screenAreas.js";
+import stitch_frag_default from "./shaders/stitch.frag.js";
+//#region ../../packages/adapters/three/src/shaderPrograms.ts
+/**
+* The fragment programs, each the GLSL chunks it is made of in the order they must appear: a
+* chunk comes after every chunk whose declarations it uses. The only place that order is known.
+*/
+var LENS_TEXELS = [lensTextures_default, displayConversion_default];
+var LENS_PROJECTION = [
+	...LENS_TEXELS,
+	lensModels_default,
+	lensSampling_default
+];
+/**
+* A program that reads the lenses through their calibration, ending in `fragment`.
+*/
+function lensProjectionProgram(fragment) {
+	return [
+		header_default,
+		...LENS_PROJECTION,
+		fragment
+	];
+}
+/**
+* The picture programs with a seam join chunk: `fixedJoin.glsl` for the player, or one that
+* implements its three functions otherwise.
+*/
+function pictureProgramsWith(seamJoin) {
+	const stitchThrough = (rays) => [
+		header_default,
+		screenAreas_default,
+		rays,
+		...LENS_PROJECTION,
+		seamJoin,
+		stitch_frag_default
+	];
+	return {
+		rectilinear: stitchThrough(rectilinearRays_default),
+		equirectangular: stitchThrough(equirectangularRays_default),
+		"lens-tiles": [
+			header_default,
+			screenAreas_default,
+			...LENS_TEXELS,
+			rawLenses_frag_default
+		]
+	};
+}
+var PICTURE_PROGRAMS = pictureProgramsWith(fixedJoin_default);
+var SEAM_ANALYSIS = lensProjectionProgram(analysis_frag_default);
+/**
+* Every chunk of the given programs once, for checking them against the TypeScript side.
+*/
+function chunksOf(programs) {
+	return [...new Set(programs.flat())];
+}
+chunksOf([...Object.values(PICTURE_PROGRAMS), SEAM_ANALYSIS]);
+//#endregion
+export { PICTURE_PROGRAMS, SEAM_ANALYSIS, chunksOf, lensProjectionProgram, pictureProgramsWith };

package/dist/packages/adapters/three/src/shaders/analysis.frag.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/analysis.frag.glsl?raw
+var analysis_frag_default = "in vec2 vNdc;\nout vec4 outColor;\n\n// One row per lens: what that lens sees along the seam ring, the circle of directions halfway\n// through the blend band around lens 0's optical axis, sampled around the ring along x. Rows\n// share their directions, so their means differ by exposure (and parallax), not by content:\n// exposure signals, in which it is a factor (ADR 0033). Alpha marks the texels a lens images.\nvoid main() {\n  int lens = int(floor((vNdc.y + 1.0) * 0.5 * float(MAX_LENSES)));\n  float phi = (vNdc.x + 1.0) * PI;\n  float ring = 0.5 * (uFeather.x + uFeather.y);\n  vec3 inLensZero = vec3(sin(ring) * cos(phi), sin(ring) * sin(phi), cos(ring));\n  // The lens rotations take body directions into each lens; the transpose goes back.\n  vec3 dirBody = transpose(uLensRotation[0]) * inLensZero;\n  if (lens >= uLensCount) {\n    outColor = vec4(0.0);\n    return;\n  }\n  LensSample seen = sampleLensWith(lens, dirBody, SAMPLING_BILINEAR);\n  outColor = seen.isImaged ? vec4(seen.signal, 1.0) : vec4(0.0);\n}\n";
+//#endregion
+export { analysis_frag_default as default };

package/dist/packages/adapters/three/src/shaders/displayConversion.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/displayConversion.glsl?raw
+var displayConversion_default = "// How lens i's texels are brought to the SDR BT.709 display, as the core's exposureSignalOf and\n// shownOf (ADR 0033): the browser's upload has applied the track's matrix and range; the\n// transfer and primaries are this chunk's. Shown as recorded, or HLG converted to scene light,\n// into BT.709 and toned; gain matching scales the exposure signal between the two (ADR 0012).\nuniform int uLensConversion[MAX_LENSES];\n// R′G′B′ through the matrix a frame names back to the track's own (matrixCorrectionOf).\nuniform mat3 uLensMatrixCorrection[MAX_LENSES];\nuniform mat3 uLensGamut[MAX_LENSES];\n// Exposure, roll-off start, roll-off ceiling, display encoding power.\nuniform vec4 uLensTone[MAX_LENSES];\n\nstruct ToneCurve {\n  float exposure;\n  float kneeStart;\n  float ceiling;\n  float exponent;\n};\n\nToneCurve toneOf(int i) {\n  vec4 tone = uLensTone[i];\n  return ToneCurve(tone.x, tone.y, tone.z, tone.w);\n}\n\nfloat hlgInverseOetf(float signal) {\n  return signal <= HLG_SEGMENT_JOIN\n    ? signal * signal / HLG_SQUARE_SEGMENT_DIVISOR\n    : (exp((signal - HLG_C) / HLG_A) + HLG_B) / HLG_LOG_SEGMENT_DIVISOR;\n}\n\nconst vec3 BT709_LUMINANCE = vec3(BT709_LUMINANCE_RED, BT709_LUMINANCE_GREEN, BT709_LUMINANCE_BLUE);\n\nfloat rolledOff(float luminance, ToneCurve tone) {\n  float over = luminance - tone.kneeStart;\n  return over <= 0.0\n    ? luminance\n    : tone.kneeStart + over / (1.0 + over / (tone.ceiling - tone.kneeStart));\n}\n\n// The signal exposed back to light, its luminance rolled off with every channel scaled alike,\n// and encoded for the display.\nvec3 tonedFrom(vec3 signal, ToneCurve tone) {\n  vec3 light = tone.exposure * pow(signal, vec3(tone.exponent));\n  float luminance = dot(light, BT709_LUMINANCE);\n  float scale = luminance > 0.0 ? rolledOff(luminance, tone) / luminance : 1.0;\n  return min(pow(light * scale, vec3(1.0 / tone.exponent)), vec3(1.0));\n}\n\nbool isHlg(int i) {\n  return uLensConversion[i] == CONVERSION_HLG_TO_SDR_BT709;\n}\n\n// Lens i's texel where its exposure is a factor; as recorded for any kind but HLG.\nvec3 exposureSignalOf(int i, vec3 texel) {\n  vec3 recorded = uLensMatrixCorrection[i] * texel;\n  if (!isHlg(i)) return recorded;\n  // A corrected texel may fall just outside the signal: below black, which the square segment\n  // would make light, or past white, which the log segment would make brighter than HLG encodes.\n  recorded = clamp(recorded, 0.0, 1.0);\n  vec3 scene = vec3(\n    hlgInverseOetf(recorded.r),\n    hlgInverseOetf(recorded.g),\n    hlgInverseOetf(recorded.b)\n  );\n  vec3 light = max(uLensGamut[i] * scene, 0.0);\n  return pow(light, vec3(1.0 / toneOf(i).exponent));\n}\n\n// An exposure signal of lens i as the display shows it; as recorded for any kind but HLG.\nvec3 shownOf(int i, vec3 signal) {\n  if (!isHlg(i)) return signal;\n  return tonedFrom(signal, toneOf(i));\n}\n\nvec3 toDisplay(int i, vec3 texel) {\n  return shownOf(i, exposureSignalOf(i, texel));\n}\n";
+//#endregion
+export { displayConversion_default as default };

package/dist/packages/adapters/three/src/shaders/equirectangularRays.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/equirectangularRays.glsl?raw
+var equirectangularRays_default = "// An equirectangular picture: a full turn across and a half turn from top to bottom.\n\n// Direction in view space (x right, y down, z forward) seen through a point of the picture, given\n// as fractions of the picture from its top-left corner.\nvec3 rayThroughPicture(vec2 point) {\n  vec2 centred = point * 2.0 - 1.0;\n  float yaw = centred.x * PI;\n  float pitch = -centred.y * HALF_PI;\n  return vec3(sin(yaw) * cos(pitch), -sin(pitch), cos(yaw) * cos(pitch));\n}\n";
+//#endregion
+export { equirectangularRays_default as default };

package/dist/packages/adapters/three/src/shaders/fixedJoin.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/fixedJoin.glsl?raw
+var fixedJoin_default = "// The fixed join: every lens read where the calibration's template reads it, for an infinitely\n// far scene, and blended across the whole feather band. The stitch the player draws; the lab's\n// bent join (ADR 0026) implements the same three functions.\nfloat disparityAt(vec3 dirBody) {\n  return 0.0;\n}\n\nvec3 seamReadDirection(int i, vec3 dirBody, float disparity) {\n  return dirBody;\n}\n\nvec2 seamFeather(float disparity) {\n  return uFeather;\n}\n";
+//#endregion
+export { fixedJoin_default as default };

package/dist/packages/adapters/three/src/shaders/fullscreen.vert.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/fullscreen.vert.glsl?raw
+var fullscreen_vert_default = "// One triangle covering the whole viewport; the fragment shader does all the work.\nin vec3 position;\nout vec2 vNdc;\n\nvoid main() {\n  vNdc = position.xy;\n  gl_Position = vec4(position.xy, 0.0, 1.0);\n}\n";
+//#endregion
+export { fullscreen_vert_default as default };

package/dist/packages/adapters/three/src/shaders/header.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/header.glsl?raw
+var header_default = "// GLSL ES 3.0 needs the default precisions before any float or int is mentioned.\nprecision highp float;\nprecision highp int;\n\nconst float PI = 3.14159265358979;\nconst float HALF_PI = 0.5 * PI;\nconst float TWO_PI = 2.0 * PI;\n";
+//#endregion
+export { header_default as default };

package/dist/packages/adapters/three/src/shaders/lensModels.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/lensModels.glsl?raw
+var lensModels_default = "// The depth is positive for every direction inside a lens's field; directions behind it are\n// projected too, for the footprint's derivatives, and must not divide by zero.\nconst float MIN_DEPTH = 1e-3;\n\nuniform vec2 uLensPrincipalPoint[MAX_LENSES];\nuniform vec2 uLensFocal[MAX_LENSES];\nuniform float uLensXi[MAX_LENSES];\n// Each Mei lens's distortion as the core's MeiDistortion holds it, lens after lens, as many terms\n// per lens as each family holds room for, by increasing order: radial terms k1, k2, ... of r²,\n// Brown's tangential pairs (p1, p2) scaled by r^(2j), and thin-prism shifts scaled by r^(2j + 2).\n// The orders a lens does not fill are zero.\nuniform float uLensRadial[MAX_LENSES * MEI_RADIAL_TERMS];\nuniform vec2 uLensTangential[MAX_LENSES * MEI_TANGENTIAL_ORDERS];\nuniform vec2 uLensThinPrism[MAX_LENSES * MEI_THIN_PRISM_ORDERS];\nuniform vec4 uLensPolynomial[MAX_LENSES];\n\n// c0 + c1 r² + c2 r⁴ + ... of each of lens i's families, by Horner's rule, as the core's seriesIn.\nfloat radialSeries(int i, float r2) {\n  float sum = 0.0;\n  for (int j = MEI_RADIAL_TERMS - 1; j >= 0; j--) {\n    sum = sum * r2 + uLensRadial[i * MEI_RADIAL_TERMS + j];\n  }\n  return sum;\n}\n\nvec2 tangentialSeries(int i, float r2) {\n  vec2 sum = vec2(0.0);\n  for (int j = MEI_TANGENTIAL_ORDERS - 1; j >= 0; j--) {\n    sum = sum * r2 + uLensTangential[i * MEI_TANGENTIAL_ORDERS + j];\n  }\n  return sum;\n}\n\nvec2 thinPrismSeries(int i, float r2) {\n  vec2 sum = vec2(0.0);\n  for (int j = MEI_THIN_PRISM_ORDERS - 1; j >= 0; j--) {\n    sum = sum * r2 + uLensThinPrism[i * MEI_THIN_PRISM_ORDERS + j];\n  }\n  return sum;\n}\n\n// A normalised image-plane point distorted by lens i, as the core's distortMei.\nvec2 distortMei(int i, vec2 m) {\n  float r2 = dot(m, m);\n  float radialFactor = 1.0 + r2 * radialSeries(i, r2);\n  vec2 decentering = tangentialSeries(i, r2);\n  vec2 tangentialTerm = vec2(\n    2.0 * decentering.x * m.x * m.y + decentering.y * (r2 + 2.0 * m.x * m.x),\n    decentering.x * (r2 + 2.0 * m.y * m.y) + 2.0 * decentering.y * m.x * m.y\n  );\n  return radialFactor * m + tangentialTerm + r2 * thinPrismSeries(i, r2);\n}\n\n// Canvas pixel of a unit direction in lens i's frame under the unified (Mei) model: project onto\n// the unit sphere, then from xi behind its centre onto the image plane, distort, scale.\nvec2 projectMei(int i, vec3 d) {\n  float depth = max(d.z + uLensXi[i], MIN_DEPTH);\n  return uLensFocal[i] * distortMei(i, d.xy / depth) + uLensPrincipalPoint[i];\n}\n\n// Canvas pixel of a unit direction under lens i's radial polynomial in the angle from its axis.\nvec2 projectRadialPolynomial(int i, vec3 d, float theta) {\n  vec4 c = uLensPolynomial[i];\n  float radius = theta * (c.x + theta * (c.y + theta * (c.z + theta * c.w)));\n  float lateral = length(d.xy);\n  vec2 unit = lateral > 0.0 ? d.xy / lateral : vec2(0.0);\n  return uLensPrincipalPoint[i] + radius * unit;\n}\n";
+//#endregion
+export { lensModels_default as default };

package/dist/packages/adapters/three/src/shaders/lensSampling.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/lensSampling.glsl?raw
+var lensSampling_default = "// How a body direction becomes a texel of one lens, for the stitch and the seam meters: the\n// pose and field as uniforms, and the sampling through each lens model, the texel as its\n// exposure signal. Needs lensTextures.glsl, displayConversion.glsl and lensModels.glsl.\nuniform vec2 uFeather;\nuniform mat3 uLensRotation[MAX_LENSES];\nuniform int uLensKind[MAX_LENSES];\nuniform float uLensHalfFov[MAX_LENSES];\nuniform vec4 uLensWindow[MAX_LENSES];\n\nstruct LensSample {\n  bool isImaged;\n  // Angle from the lens's optical axis.\n  float theta;\n  // The texel where the lens's exposure is a factor (displayConversion.glsl).\n  vec3 signal;\n};\n\n// Where lens i images direction d on its calibration canvas; the principal point, and not\n// known, for a kind of lens this shader does not know.\nvec2 canvasPixel(int i, vec3 d, float theta, out bool isKnown) {\n  isKnown = true;\n  if (uLensKind[i] == LENS_MEI) {\n    return projectMei(i, d);\n  }\n  if (uLensKind[i] == LENS_RADIAL_POLYNOMIAL) {\n    return projectRadialPolynomial(i, d, theta);\n  }\n  isKnown = false;\n  return uLensPrincipalPoint[i];\n}\n\n// What lens i shows in a body direction, read as `sampling` says, if it images it at all:\n// outside its field, or beyond the window the frame shows, nothing. The footprint is taken and\n// the texture read in every fragment before the gates: a read inside a branch that some pixels\n// of a 2x2 quad skip took a far too coarse footprint on Apple GPUs (rawLenses.frag.glsl).\nLensSample sampleLensWith(int i, vec3 dirBody, int sampling) {\n  vec3 d = uLensRotation[i] * dirBody;\n  // atan keeps its precision near the axis where acos loses it.\n  float theta = atan(length(d.xy), d.z);\n  bool isKnown;\n  vec2 pixel = canvasPixel(i, d, theta, isKnown);\n  vec2 windowUv = (pixel - uLensWindow[i].xy) / uLensWindow[i].zw;\n  Footprint footprint = footprintOf(i, windowUv);\n  bool isInWindow =\n    all(greaterThanEqual(windowUv, vec2(0.0))) && all(lessThanEqual(windowUv, vec2(1.0)));\n  vec3 texel = sampleLens(uLensTexture[i], footprint, sampling).rgb;\n  LensSample result;\n  result.theta = theta;\n  result.isImaged = isKnown && theta < uLensHalfFov[i] && isInWindow;\n  result.signal = result.isImaged ? exposureSignalOf(i, texel) : vec3(0.0);\n  return result;\n}\n\n// What lens i shows in a body direction, read as the picture is.\nLensSample sampleLensAt(int i, vec3 dirBody) {\n  return sampleLensWith(i, dirBody, uSampling);\n}\n";
+//#endregion
+export { lensSampling_default as default };

package/dist/packages/adapters/three/src/shaders/lensTextures.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/lensTextures.glsl?raw
+var lensTextures_default = "// Where each lens's image is: the decoded frames as textures, each lens's region of its frame,\n// and how a screen pixel reads them. Every program that reads a lens needs these.\nuniform int uLensCount;\nuniform vec4 uLensRegion[MAX_LENSES];\nuniform int uLensTexture[MAX_LENSES];\nuniform sampler2D uTexture0;\nuniform sampler2D uTexture1;\nuniform int uSampling;\n\n// The patch of a lens image one screen pixel covers: where it is read, and how far the next\n// pixel to the right and the next one down move the read, from the screen derivatives.\nstruct Footprint {\n  vec2 uv;\n  vec2 dx;\n  vec2 dy;\n};\n\nvec2 texelSizeOf(int textureIndex) {\n  return 1.0 / vec2(textureIndex == 0 ? textureSize(uTexture0, 0) : textureSize(uTexture1, 0));\n}\n\n// One bilinear tap of the base level, whatever the texture's filters: the seam meters read the\n// frames this way, where the pixel footprint means nothing.\nvec4 fetchBase(int textureIndex, vec2 uv) {\n  return textureIndex == 0\n    ? textureLod(uTexture0, uv, 0.0)\n    : textureLod(uTexture1, uv, 0.0);\n}\n\n// One tap through the mip chain over a footprint.\nvec4 fetchFootprint(int textureIndex, vec2 uv, vec2 dx, vec2 dy) {\n  return textureIndex == 0\n    ? textureGrad(uTexture0, uv, dx, dy)\n    : textureGrad(uTexture1, uv, dx, dy);\n}\n\n// Where a fraction of a lens's region is read. The derivatives are taken here, in every\n// fragment alike, before anything decides whether the pixel shows the lens at all; then the read\n// point is kept half a texel inside the region, so a neighbouring region never bleeds in.\nFootprint footprintOf(int i, vec2 regionUv) {\n  vec2 uv = uLensRegion[i].xy + regionUv * uLensRegion[i].zw;\n  Footprint footprint;\n  footprint.dx = dFdx(uv);\n  footprint.dy = dFdy(uv);\n  vec2 inset = 0.5 * texelSizeOf(uLensTexture[i]);\n  vec2 low = uLensRegion[i].xy + inset;\n  vec2 high = uLensRegion[i].xy + uLensRegion[i].zw - inset;\n  footprint.uv = clamp(uv, low, high);\n  return footprint;\n}\n\n// Four taps on a rotated grid within the footprint, each over a quarter of it (Akenine-Möller\n// et al., Real-Time Rendering, 4th ed., section 5.4.1).\nconst vec2 GRID_OFFSETS[4] = vec2[4](\n  vec2(-0.375, 0.125),\n  vec2(0.125, 0.375),\n  vec2(0.375, -0.125),\n  vec2(-0.125, -0.375)\n);\n\nvec4 fetchSupersampled(int textureIndex, Footprint footprint) {\n  vec4 sum = vec4(0.0);\n  for (int tap = 0; tap < 4; tap++) {\n    vec2 uv =\n      footprint.uv + GRID_OFFSETS[tap].x * footprint.dx + GRID_OFFSETS[tap].y * footprint.dy;\n    sum += fetchFootprint(textureIndex, uv, 0.5 * footprint.dx, 0.5 * footprint.dy);\n  }\n  return 0.25 * sum;\n}\n\nvec4 sampleLens(int textureIndex, Footprint footprint, int sampling) {\n  if (sampling == SAMPLING_TRILINEAR) {\n    return fetchFootprint(textureIndex, footprint.uv, footprint.dx, footprint.dy);\n  }\n  if (sampling == SAMPLING_SUPERSAMPLED) return fetchSupersampled(textureIndex, footprint);\n  return fetchBase(textureIndex, footprint.uv);\n}\n";
+//#endregion
+export { lensTextures_default as default };

package/dist/packages/adapters/three/src/shaders/rawLenses.frag.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/rawLenses.frag.glsl?raw
+var rawLenses_frag_default = "// The decoded lens images on their own, unstitched: each lens's region of its frame as the\n// decoder delivered it, brought to the display (ADR 0033), in the lens's screen area, with no\n// pose, stabilization or gain. Black around the areas. Every pixel reads every tile, and the area\n// picks one without a branch: a read inside a branch that some pixels of a 2x2 quad skip took a\n// far too coarse footprint on Apple GPUs (Chrome through Metal), a grey line along a tile's edge\n// wherever the edge fell inside a quad.\nin vec2 vNdc;\nout vec4 outColor;\n\nvoid main() {\n  vec3 color = vec3(0.0);\n  for (int i = 0; i < MAX_LENSES; i++) {\n    if (i >= uLensCount) break;\n    vec2 point = pointInArea(vNdc, uScreenArea[i]);\n    Footprint footprint = footprintOf(i, point);\n    vec3 sampled = toDisplay(i, sampleLens(uLensTexture[i], footprint, uSampling).rgb);\n    color = mix(color, sampled, float(isInArea(point)));\n  }\n  outColor = vec4(color, 1.0);\n}\n";
+//#endregion
+export { rawLenses_frag_default as default };

package/dist/packages/adapters/three/src/shaders/rectilinearRays.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/rectilinearRays.glsl?raw
+var rectilinearRays_default = "// A rectilinear picture: the image plane scaled so that the horizontal field of view means what\n// the picture says.\nuniform float uPlaneHalfExtent;\nuniform float uPictureAspect;\n\n// Direction in view space (x right, y down, z forward) seen through a point of the picture, given\n// as fractions of the picture from its top-left corner.\nvec3 rayThroughPicture(vec2 point) {\n  vec2 centred = point * 2.0 - 1.0;\n  vec2 plane = vec2(centred.x * uPlaneHalfExtent, centred.y * uPlaneHalfExtent / uPictureAspect);\n  return normalize(vec3(plane, 1.0));\n}\n";
+//#endregion
+export { rectilinearRays_default as default };

package/dist/packages/adapters/three/src/shaders/screenAreas.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/screenAreas.glsl?raw
+var screenAreas_default = "// Where on the viewport the picture goes: per area, x, y, width and height as fractions of the\n// viewport from its top-left corner.\nuniform vec4 uScreenArea[MAX_LENSES];\n\n// Where a pixel lies within an area, as fractions of the area from its top-left corner: outside\n// 0 to 1 when the pixel lies outside the area. Normalised device y points up, screen y down.\nvec2 pointInArea(vec2 ndc, vec4 area) {\n  vec2 screen = vec2(ndc.x + 1.0, 1.0 - ndc.y) * 0.5;\n  return (screen - area.xy) / area.zw;\n}\n\nbool isInArea(vec2 point) {\n  return all(greaterThanEqual(point, vec2(0.0))) && all(lessThanEqual(point, vec2(1.0)));\n}\n";
+//#endregion
+export { screenAreas_default as default };

package/dist/packages/adapters/three/src/shaders/stitch.frag.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/stitch.frag.glsl?raw
+var stitch_frag_default = "// The stitched sphere through the picture's rays: each lens's texel for the ray, read and weighted\n// across the feather band as the seam join says, and matched in exposure. Every pixel drawn\n// samples, even outside the picture's area (the renderer's scissor box holds the area and a\n// pixel around it), so the footprints' derivatives are defined; the area decides what shows.\nuniform mat3 uViewRotation;\nuniform mat3 uStabilization;\nuniform vec3 uLensGain[MAX_LENSES];\n\nin vec2 vNdc;\nout vec4 outColor;\n\nvoid main() {\n  vec2 point = pointInArea(vNdc, uScreenArea[0]);\n  vec3 dirView = rayThroughPicture(point);\n  vec3 dirBody = uStabilization * (uViewRotation * dirView);\n  vec3 sum = vec3(0.0);\n  float weightSum = 0.0;\n  float disparity = disparityAt(dirBody);\n  vec2 feather = seamFeather(disparity);\n  for (int i = 0; i < MAX_LENSES; i++) {\n    if (i >= uLensCount) break;\n    // A lens silenced through its gain (ADR 0012) leaves the blend altogether, so the other\n    // lens fills the feather band alone and a lens-only render shows that lens as it is.\n    if (all(equal(uLensGain[i], vec3(0.0)))) continue;\n    LensSample lens = sampleLensAt(i, seamReadDirection(i, dirBody, disparity));\n    if (!lens.isImaged) continue;\n    // Weighed by the angle from the lens's axis where it is read, which a seam join may move.\n    float weight = 1.0 - smoothstep(feather.x, feather.y, lens.theta);\n    // Matched in exposure where exposure is a factor, then brought to the display (ADR 0033).\n    sum += weight * shownOf(i, uLensGain[i] * lens.signal);\n    weightSum += weight;\n  }\n  bool isShown = isInArea(point) && weightSum > 0.0;\n  outColor = isShown ? vec4(sum / weightSum, 1.0) : vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
+//#endregion
+export { stitch_frag_default as default };

package/dist/packages/adapters/three/src/threeMatrix.js

@@ -0,0 +1,10 @@
+import { Matrix3 } from "three";
+//#region ../../packages/adapters/three/src/threeMatrix.ts
+/**
+* Row-major core matrix into a three matrix, whose `set` takes rows too.
+*/
+function toThreeMatrix(m) {
+	return new Matrix3().set(...m);
+}
+//#endregion
+export { toThreeMatrix };

package/dist/packages/adapters/three/src/webglRenderer.js

@@ -0,0 +1,37 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { WebGLRenderer } from "three";
+//#region ../../packages/adapters/three/src/webglRenderer.ts
+/**
+* The WebGL 2 context a picture renderer draws on, wrapped by three, with every shader failure
+* made an error.
+*/
+function createRenderer(canvas, options) {
+	const context = canvas.getContext("webgl2", {
+		preserveDrawingBuffer: options.preserveDrawingBuffer ?? false,
+		antialias: false,
+		alpha: false,
+		depth: false,
+		stencil: false
+	});
+	if (!context) throw new GyroViewError("render-unavailable", "this browser has no WebGL2 context");
+	if (context.isContextLost()) throw new GyroViewError("render-unavailable", "the canvas's WebGL2 context has been lost");
+	const renderer = new WebGLRenderer({
+		canvas,
+		context
+	});
+	renderer.setPixelRatio(1);
+	renderer.debug.onShaderError = (gl, program, ...shaders) => {
+		rejectProgram(gl, program, shaders);
+	};
+	return renderer;
+}
+/**
+* A shader that does not compile or link is a defect, not something to log and draw black over.
+* A compile failure's reason is in its shader's log, a link failure's in the program's.
+*/
+function rejectProgram(gl, program, shaders) {
+	const log = [gl.getProgramInfoLog(program), ...shaders.map((shader) => gl.getShaderInfoLog(shader))].filter(Boolean).join("\n");
+	throw new GyroViewError("render-unavailable", `a shader did not compile or link: ${log}`);
+}
+//#endregion
+export { createRenderer };

package/dist/packages/adapters/webcodecs/src/WebCodecsVideoDecoderPort.js

@@ -0,0 +1,152 @@
+import { GyroViewError, asGyroViewError, messageOf } from "../../../core/src/shared/errors/GyroViewError.js";
+import { microseconds, microsecondsToSeconds, secondsToMicroseconds } from "../../../core/src/shared/units/time.js";
+import { colorSpaceOf } from "./colorSpaceOf.js";
+//#region ../../packages/adapters/webcodecs/src/WebCodecsVideoDecoderPort.ts
+/**
+* A hard `prefer-hardware` refuses codecs the browser could decode in software (H.264 recordings
+* on machines without a hardware decoder); with no preference the browser still picks hardware
+* when it has it (ADR 0010).
+*/
+var HARDWARE_ACCELERATION = "no-preference";
+/**
+* VideoDecoderPort over the browser's WebCodecs `VideoDecoder`. Frames are exposed as
+* `DecodedFrame<VideoFrame>`; the renderer uploads the handle to the GPU and the pipeline closes
+* it afterwards.
+*/
+var WebCodecsVideoDecoderPort = class {
+	/**
+	* A configuration WebCodecs finds malformed is one it does not support. A browser without
+	* WebCodecs refuses to answer, since no configuration would do.
+	*/
+	async isSupported(configuration) {
+		if (typeof VideoDecoder === "undefined") throw webCodecsUnavailable();
+		try {
+			return (await VideoDecoder.isConfigSupported(this.toWebCodecsConfig(configuration))).supported === true;
+		} catch {
+			return false;
+		}
+	}
+	create(configuration, callbacks) {
+		try {
+			return Promise.resolve(this.configureDecoder(configuration, callbacks));
+		} catch (error) {
+			return Promise.reject(asGyroViewError(error, "codec-unsupported", "the decoder rejected its configuration"));
+		}
+	}
+	configureDecoder(configuration, callbacks) {
+		if (typeof VideoDecoder === "undefined") throw webCodecsUnavailable();
+		return new WebCodecsDecoderHandle(this.toWebCodecsConfig(configuration), callbacks);
+	}
+	toWebCodecsConfig(configuration) {
+		const { description } = configuration;
+		const colorSpace = colorSpaceOf(configuration.colour);
+		return {
+			codec: configuration.codec,
+			codedWidth: configuration.codedWidth,
+			codedHeight: configuration.codedHeight,
+			...description && { description },
+			...colorSpace && { colorSpace },
+			hardwareAcceleration: HARDWARE_ACCELERATION,
+			optimizeForLatency: false
+		};
+	}
+};
+/**
+* One configured `VideoDecoder` for its whole life. The error it reported through its callback
+* is kept, so later calls fail with the real cause instead of a bare "closed" state.
+*/
+var WebCodecsDecoderHandle = class {
+	decoder;
+	failure;
+	constructor(config, callbacks) {
+		this.decoder = new VideoDecoder({
+			output: (frame) => {
+				callbacks.onFrame(wrapFrame(frame));
+			},
+			error: (error) => {
+				this.failure ??= new GyroViewError("decode", `video decoder failed: ${error.message}`, { cause: error });
+				callbacks.onError(this.failure);
+			}
+		});
+		try {
+			this.decoder.configure(config);
+		} catch (error) {
+			this.decoder.close();
+			throw error;
+		}
+	}
+	get pendingCount() {
+		return this.decoder.decodeQueueSize;
+	}
+	/**
+	* WebCodecs throws platform exceptions for a packet it refuses (a delta frame first, a closed
+	* decoder); they cross the port as `decode` failures, as the fake's do.
+	*/
+	decode(packet) {
+		if (this.failure) throw this.failure;
+		try {
+			this.decoder.decode(chunkOf(packet));
+		} catch (error) {
+			throw new GyroViewError("decode", `the decoder refused a packet: ${messageOf(error)}`, { cause: error });
+		}
+	}
+	/**
+	* Resolves on the decoder's `dequeue` events until fewer than `limit` packets are pending, or
+	* at once when the decoder is no longer configured.
+	*/
+	waitForPendingBelow(limit) {
+		return this.decoder.decodeQueueSize < limit ? Promise.resolve() : new Promise((resolve) => {
+			const check = () => {
+				if (this.decoder.decodeQueueSize >= limit && this.decoder.state === "configured") return;
+				this.decoder.removeEventListener("dequeue", check);
+				resolve();
+			};
+			this.decoder.addEventListener("dequeue", check);
+		});
+	}
+	async flush() {
+		if (this.decoder.state !== "configured") throw this.failure ?? new GyroViewError("decode", "flush on a closed decoder");
+		try {
+			await this.decoder.flush();
+		} catch (error) {
+			throw this.failure ?? new GyroViewError("decode", "the decoder could not be flushed", { cause: error });
+		}
+	}
+	close() {
+		if (this.decoder.state !== "closed") this.decoder.close();
+	}
+};
+/**
+* Browsers expose WebCodecs only in secure contexts, so a page served over plain HTTP is the
+* likelier cause than an old browser, and the one its developer can fix.
+*/
+function webCodecsUnavailable() {
+	const reason = globalThis.isSecureContext ? "this browser has no WebCodecs VideoDecoder" : "WebCodecs exists only in secure contexts (HTTPS), and this page is not one";
+	return new GyroViewError("webcodecs-unavailable", reason);
+}
+function chunkOf(packet) {
+	return new EncodedVideoChunk({
+		type: packet.isKeyFrame ? "key" : "delta",
+		timestamp: wholeMicrosecondsOf(packet.timestamp),
+		duration: wholeMicrosecondsOf(packet.duration),
+		data: packet.data
+	});
+}
+/**
+* The nearest whole microsecond: a chunk's times are integers, which WebIDL would otherwise reach
+* by truncation, a microsecond early for a time like 0.8 s that floating point holds as 0.7999….
+*/
+function wholeMicrosecondsOf(time) {
+	return Math.round(secondsToMicroseconds(time));
+}
+function wrapFrame(frame) {
+	return {
+		timestamp: microsecondsToSeconds(microseconds(frame.timestamp)),
+		handle: frame,
+		close: () => {
+			frame.close();
+		}
+	};
+}
+//#endregion
+export { WebCodecsVideoDecoderPort };

package/dist/packages/adapters/webcodecs/src/colorSpaceOf.js

@@ -0,0 +1,32 @@
+//#region ../../packages/adapters/webcodecs/src/colorSpaceOf.ts
+/**
+* A track's colour as a decoder configuration's colour space: every value the track names, none
+* it leaves unspecified. WebCodecs gives the frames the configured colour space whole ("Output
+* VideoFrames"), so it says all the bitstream says, and the frames carry the colour the display
+* conversion was chosen for (ADR 0033). An engine whose WebCodecs does not know one of the values
+* would refuse the whole configuration, so it is told the range alone, as before. Undefined for a
+* track that names nothing.
+*/
+function colorSpaceOf(colour) {
+	const range = colour.range === "unspecified" ? void 0 : { fullRange: colour.range === "full" };
+	const named = {
+		...colour.primaries !== "unspecified" && { primaries: colour.primaries },
+		...colour.transfer !== "unspecified" && { transfer: colour.transfer },
+		...colour.matrix !== "unspecified" && { matrix: colour.matrix },
+		...range
+	};
+	return Object.keys(named).length === 0 ? void 0 : understoodHere(named) ?? range;
+}
+/**
+* The colour space as this engine reads it, undefined where it names a value the engine does not
+* know.
+*/
+function understoodHere(colorSpace) {
+	try {
+		return new VideoColorSpace(colorSpace).toJSON();
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { colorSpaceOf };

package/dist/packages/core/src/application/download/BlockStore.js

@@ -0,0 +1,97 @@
+import { ensureInvariant } from "../../shared/errors/GyroViewError.js";
+import { ByteRange } from "../../shared/binary/ByteRange.js";
+import { ByteRangeSet } from "../../shared/binary/ByteRangeSet.js";
+//#region ../../packages/core/src/application/download/BlockStore.ts
+var FillingBlock = class {
+	range;
+	bytes;
+	filled = 0;
+	/**
+	* No more of its bytes will come: all have, or its range was given up.
+	*/
+	isComplete = false;
+	constructor(range, bytes) {
+		this.range = range;
+		this.bytes = bytes;
+	}
+	get filledRange() {
+		return ByteRange.of(this.range.offset, this.filled);
+	}
+};
+/**
+* The bytes a download holds, a block for each range it asked for. A range within one block is
+* handed out as a view of it; one across blocks is copied out of them.
+*/
+var BlockStore = class {
+	blocks = [];
+	get held() {
+		return ByteRangeSet.of(this.blocks.map((block) => block.filledRange));
+	}
+	/**
+	* The memory the blocks take, whether their bytes have come or not.
+	*/
+	get allocatedBytes() {
+		return this.blocks.reduce((total, block) => total + block.bytes.byteLength, 0);
+	}
+	allocate(range) {
+		const block = new FillingBlock(range, new Uint8Array(range.length));
+		this.blocks.push(block);
+		return block;
+	}
+	write(block, chunk) {
+		const filling = this.fillingOf(block);
+		filling.bytes.set(chunk, filling.filled);
+		filling.filled += chunk.byteLength;
+	}
+	/**
+	* Every byte of the block has come.
+	*/
+	complete(block) {
+		this.fillingOf(block).isComplete = true;
+	}
+	/**
+	* Keeps of a block only what has come, as when its range is given up; a block that got
+	* nothing goes.
+	*/
+	trim(block) {
+		const filling = this.fillingOf(block);
+		filling.isComplete = true;
+		filling.bytes = filling.bytes.slice(0, filling.filled);
+		this.blocks = this.blocks.filter((held) => held.bytes.byteLength > 0);
+	}
+	/**
+	* The bytes of `range`, if every one of them has come.
+	*/
+	bytesOf(range) {
+		const within = this.blocks.find((block) => block.filledRange.contains(range));
+		if (within) return viewOf(within, range);
+		return this.held.covers(range) ? this.copyOf(range) : void 0;
+	}
+	/**
+	* Lets go of the complete blocks whose every byte `released` holds; a block still filling is
+	* its transfer's until it ends.
+	*/
+	release(released) {
+		this.blocks = this.blocks.filter((block) => !block.isComplete || !released.covers(block.filledRange));
+	}
+	fillingOf(block) {
+		const filling = this.blocks.find((held) => held === block);
+		ensureInvariant(filling !== void 0, "the block is not one this store holds");
+		return filling;
+	}
+	copyOf(range) {
+		const copy = new Uint8Array(range.length);
+		for (const block of this.blocks) {
+			const start = Math.max(block.range.offset, range.offset);
+			const end = Math.min(block.filledRange.end, range.end);
+			if (start < end) copy.set(block.bytes.subarray(start - block.range.offset, end - block.range.offset), start - range.offset);
+		}
+		return copy;
+	}
+};
+function viewOf(block, range) {
+	const start = range.offset - block.range.offset;
+	return block.bytes.subarray(start, start + range.length);
+}
+//#endregion
+export { BlockStore };

package/dist/packages/core/src/application/download/DownloadedAudioSamples.js

@@ -0,0 +1,50 @@
+import { Ending, ITERATION_END } from "../../shared/async/iteration.js";
+//#region ../../packages/core/src/application/download/DownloadedAudioSamples.ts
+/**
+* A sound track's samples read through the file's download, within the picture's reach.
+*/
+var DownloadedAudioSamples = class {
+	parts;
+	constructor(parts) {
+		this.parts = parts;
+	}
+	get duration() {
+		return this.parts.track.end;
+	}
+	samplesFrom(time) {
+		const { download, track } = this.parts;
+		return { [Symbol.asyncIterator]: () => new SampleReading(track, download.openCursor(track, track.sampleShownAt(time) ?? 0, time)) };
+	}
+};
+/**
+* One iteration over the samples; each is copied out of what was downloaded, so the samples a
+* media pipeline keeps do not keep the download's blocks alive.
+*/
+var SampleReading = class {
+	track;
+	cursor;
+	ending = new Ending();
+	constructor(track, cursor) {
+		this.track = track;
+		this.cursor = cursor;
+	}
+	async next() {
+		const read = await this.cursor.nextSample();
+		if (!read || this.ending.hasEnded()) return ITERATION_END;
+		return {
+			done: false,
+			value: {
+				timestamp: this.track.timestampOf(read.sample),
+				duration: this.track.durationOf(read.sample),
+				data: Uint8Array.from(read.bytes)
+			}
+		};
+	}
+	return() {
+		this.ending.end();
+		this.cursor.close();
+		return Promise.resolve(ITERATION_END);
+	}
+};
+//#endregion
+export { DownloadedAudioSamples };