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

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

@@ -0,0 +1,52 @@
+import { SHADER_DEFINES } from "./rendererUniforms.js";
+import fullscreen_vert_default from "./shaders/fullscreen.vert.js";
+import { BufferGeometry, Float32BufferAttribute, GLSL3, RawShaderMaterial } from "three";
+//#region ../../packages/adapters/three/src/fullscreenPass.ts
+/**
+* One triangle covering the clip square: two corners lie beyond it so its hypotenuse clears the
+* far edge. The fragment shader decides every pixel.
+*/
+var BEYOND_CLIP = 3;
+var FULLSCREEN_TRIANGLE = [
+	-1,
+	-1,
+	0,
+	BEYOND_CLIP,
+	-1,
+	0,
+	-1,
+	BEYOND_CLIP,
+	0
+];
+var POSITION_COMPONENTS = 3;
+function createFullscreenTriangle() {
+	const geometry = new BufferGeometry();
+	geometry.setAttribute("position", new Float32BufferAttribute(FULLSCREEN_TRIANGLE, POSITION_COMPONENTS));
+	return geometry;
+}
+/**
+* The program of a pass whose chunks refer only to the constants of `rendererUniforms`.
+*/
+function programOf(chunks) {
+	return {
+		chunks,
+		defines: SHADER_DEFINES
+	};
+}
+/**
+* A fullscreen pass over the shared uniforms. The raw shaders ignore the camera three still
+* wants to render with; each pass keeps its own.
+*/
+function createPassMaterial(uniforms, program) {
+	return new RawShaderMaterial({
+		glslVersion: GLSL3,
+		defines: { ...program.defines },
+		vertexShader: fullscreen_vert_default,
+		fragmentShader: program.chunks.join("\n"),
+		uniforms: { ...uniforms },
+		depthTest: false,
+		depthWrite: false
+	});
+}
+//#endregion
+export { createFullscreenTriangle, createPassMaterial, programOf };

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

@@ -0,0 +1,10 @@
+//#region ../../packages/adapters/three/src/glslLiterals.ts
+/**
+* A number as a GLSL float literal, with its decimal point: three.js writes a define's number as
+* JavaScript prints it, so 3 would be an int, and GLSL ES 3.00 converts no int to a float.
+*/
+function glslFloat(value) {
+	return Number.isSafeInteger(value) ? value.toFixed(1) : String(value);
+}
+//#endregion
+export { glslFloat };

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

@@ -0,0 +1,34 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { LinearFilter, NoColorSpace, VideoFrameTexture } from "three";
+//#region ../../packages/adapters/three/src/lensTextures.ts
+/**
+* The textures the decoded frames are uploaded to, one per frame of a pair, read with the
+* given strategy. Three uploads a video frame with `texImage2D` and builds the mip chain after
+* it when asked; the anisotropy applies where the driver offers it and the filter uses the
+* chain.
+*/
+function createLensTextures(count, strategy) {
+	return Array.from({ length: count }, () => {
+		const texture = new VideoFrameTexture();
+		texture.flipY = false;
+		texture.colorSpace = NoColorSpace;
+		texture.magFilter = LinearFilter;
+		applyTextureFilters(texture, strategy);
+		return texture;
+	});
+}
+function applyTextureFilters(texture, strategy) {
+	texture.minFilter = strategy.minFilter;
+	texture.generateMipmaps = strategy.generateMipmaps;
+	texture.anisotropy = strategy.anisotropy;
+}
+/**
+* Three would shrink a frame larger than the GPU's largest texture through a 2D canvas at every
+* upload, slowly and blurred, saying nothing; such a frame is refused instead.
+*/
+function ensureUploadable(frame, maxTextureSize) {
+	if (Math.max(frame.displayWidth, frame.displayHeight) <= maxTextureSize) return;
+	throw new GyroViewError("render-unavailable", `this GPU holds textures of at most ${maxTextureSize} pixels a side; a decoded frame is ${frame.displayWidth} x ${frame.displayHeight}`);
+}
+//#endregion
+export { applyTextureFilters, createLensTextures, ensureUploadable };

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

@@ -0,0 +1,34 @@
+import { MATRIX_COEFFICIENTS, namedOrUnspecified } from "../../../core/src/domain/colour/TrackColour.js";
+import { matrixCorrectionOf } from "../../../core/src/domain/colour/matrixCorrection.js";
+import { toThreeMatrix } from "./threeMatrix.js";
+//#region ../../packages/adapters/three/src/matrixCorrections.ts
+/**
+* Follows the matrix each lens's frames name, and brings their texels back to the matrix the
+* track was recorded with where the two differ (ADR 0033): WebKit's decoders convert Y′CbCr with
+* BT.709 whatever a stream says, and name BT.709 on the frames they make.
+*/
+var MatrixCorrections = class {
+	lenses;
+	uniform;
+	named;
+	constructor(lenses, uniform) {
+		this.lenses = lenses;
+		this.uniform = uniform;
+		this.named = Array.from({ length: lenses.length });
+	}
+	/**
+	* Updates a lens's correction when its frames name another matrix than before.
+	*/
+	follow(frames) {
+		for (const [index, lens] of this.lenses.entries()) {
+			const frame = frames[lens.frameSlot];
+			if (!frame) continue;
+			const named = namedOrUnspecified(MATRIX_COEFFICIENTS, frame.colorSpace.matrix);
+			if (named === this.named[index]) continue;
+			this.named[index] = named;
+			this.uniform.value[index] = toThreeMatrix(matrixCorrectionOf(lens.displayConversion.matrix, named));
+		}
+	}
+};
+//#endregion
+export { MatrixCorrections };

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

@@ -0,0 +1,44 @@
+import { SHADER_DEFINES } from "./rendererUniforms.js";
+import { createPassMaterial } from "./fullscreenPass.js";
+import { compileAndProve } from "./compileAndProve.js";
+import { PICTURE_PROGRAMS } from "./shaderPrograms.js";
+import { Camera, Mesh, Scene } from "three";
+//#region ../../packages/adapters/three/src/pictureMaterials.ts
+/**
+* The pictures the player draws: the stitch through the fixed seam join.
+*/
+var PLAYER_SHADERS = {
+	programs: PICTURE_PROGRAMS,
+	defines: SHADER_DEFINES
+};
+/**
+* The pictures' materials over the shared uniforms, and any the pictures' programs add.
+*/
+function createPictureMaterials(uniforms, shaders) {
+	const materialOf = (kind) => createPassMaterial(uniforms, {
+		chunks: shaders.programs[kind],
+		defines: shaders.defines
+	});
+	return {
+		rectilinear: materialOf("rectilinear"),
+		equirectangular: materialOf("equirectangular"),
+		"lens-tiles": materialOf("lens-tiles")
+	};
+}
+/**
+* Compiles and proves every program now: a broken shader then fails here rather than at the first
+* presented frame or the first change of view mode, and a change of mode is instant.
+*/
+function compilePictureMaterials(renderer, geometry, materials) {
+	const camera = new Camera();
+	for (const material of Object.values(materials)) {
+		const scene = new Scene();
+		scene.add(new Mesh(geometry, material));
+		compileAndProve(renderer, scene, camera);
+	}
+}
+function disposePictureMaterials(materials) {
+	for (const material of Object.values(materials)) material.dispose();
+}
+//#endregion
+export { PLAYER_SHADERS, compilePictureMaterials, createPictureMaterials, disposePictureMaterials };

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

@@ -0,0 +1,15 @@
+//#region ../../packages/adapters/three/src/renderInto.ts
+/**
+* Runs `draw` with `target` bound, the renderer's own target restored however the drawing ends.
+*/
+function renderInto(renderer, target, draw) {
+	const previous = renderer.getRenderTarget();
+	renderer.setRenderTarget(target);
+	try {
+		draw();
+	} finally {
+		renderer.setRenderTarget(previous);
+	}
+}
+//#endregion
+export { renderInto };

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

@@ -0,0 +1,108 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { DEFAULT_PICTURE_QUALITY } from "../../../core/src/domain/view/PictureQuality.js";
+import { createLensTextures } from "./lensTextures.js";
+import { DRAW_AT_ONCE } from "./drawSchedules.js";
+import { SAMPLING_STRATEGIES } from "./samplingStrategies.js";
+import { applyShaderSampling, createRendererUniforms } from "./rendererUniforms.js";
+import { createFullscreenTriangle } from "./fullscreenPass.js";
+import { MatrixCorrections } from "./matrixCorrections.js";
+import { PLAYER_SHADERS, compilePictureMaterials, createPictureMaterials, disposePictureMaterials } from "./pictureMaterials.js";
+import { SeamMeterPass } from "./seamMeter/SeamMeterPass.js";
+import { createRenderer } from "./webglRenderer.js";
+import { Camera, Mesh, Scene } from "three";
+//#region ../../packages/adapters/three/src/rendererParts.ts
+var PLAYER_PICTURES = {
+	shaders: PLAYER_SHADERS,
+	uniforms: {}
+};
+/**
+* The parts a renderer was built of, disposed of together, the last built first: on the renderer's
+* disposal, and at once when a later part fails to build (a shader the GPU refuses), so a failed
+* opening leaves nothing behind.
+*/
+var BuiltParts = class BuiltParts {
+	parts = [];
+	static disposedOnFailure(build) {
+		const built = new BuiltParts();
+		try {
+			return build(built);
+		} catch (error) {
+			built.dispose();
+			throw error;
+		}
+	}
+	keep(part) {
+		this.parts.push(part);
+		return part;
+	}
+	dispose() {
+		for (let part = this.parts.pop(); part; part = this.parts.pop()) part.dispose();
+	}
+};
+/**
+* The context, textures, uniforms and compiled programs of a renderer that draws with the given
+* pictures. Every program is compiled and proven here, so a broken shader fails at creation
+* rather than at the first frame, and a change of view mode is instant.
+*/
+function openRendererParts(canvas, setup, opening) {
+	ensureDrawable(setup);
+	return BuiltParts.disposedOnFailure((built) => {
+		const renderer = built.keep(createRenderer(canvas, opening.options));
+		const shared = sharedParts(setup, opening.pictures, built);
+		const pass = new Mesh(built.keep(createFullscreenTriangle()), shared.materials.rectilinear);
+		compilePictureMaterials(renderer, pass.geometry, shared.materials);
+		const seamProof = built.keep(new SeamMeterPass(renderer, shared.uniforms, setup.lenses.length));
+		return {
+			...shared,
+			renderer,
+			scene: new Scene().add(pass),
+			camera: new Camera(),
+			pass,
+			matrixCorrections: new MatrixCorrections(setup.lenses, shared.uniforms.uLensMatrixCorrection),
+			lensCount: setup.lenses.length,
+			drawSchedule: opening.options.drawSchedule ?? DRAW_AT_ONCE,
+			seamProof,
+			built
+		};
+	});
+}
+/**
+* Compiles and proves the parts' programs again, as at opening: three builds every program anew
+* on a restored context, at its first use otherwise, which would compile on screen in the frame
+* that draws it and at each first change of view mode.
+*/
+function compileAgain(parts) {
+	compilePictureMaterials(parts.renderer, parts.pass.geometry, parts.materials);
+	parts.seamProof.prove();
+}
+/**
+* The shader has room for `MAX_LENSES` lenses from `LENS_TEXTURES` decoded frames; a layout
+* beyond either would be drawn wrong without a word, so it is refused.
+*/
+function ensureDrawable(setup) {
+	if (setup.lenses.length <= 2 && setup.frameSlotCount <= 2) return;
+	throw new GyroViewError("unsupported-layout", `the renderer draws at most 2 lenses from 2 frames; the layout has ${setup.lenses.length} lenses in ${setup.frameSlotCount} frames`);
+}
+/**
+* The textures, uniforms and programs every picture shares, read at the default quality.
+*/
+function sharedParts(setup, pictures, built) {
+	const strategy = SAMPLING_STRATEGIES[DEFAULT_PICTURE_QUALITY];
+	const textures = createLensTextures(setup.frameSlotCount, strategy).map((texture) => built.keep(texture));
+	const uniforms = createRendererUniforms(setup, textures);
+	applyShaderSampling(uniforms, strategy);
+	const materials = createPictureMaterials({
+		...uniforms,
+		...pictures.uniforms
+	}, pictures.shaders);
+	built.keep({ dispose: () => {
+		disposePictureMaterials(materials);
+	} });
+	return {
+		textures,
+		uniforms,
+		materials
+	};
+}
+//#endregion
+export { BuiltParts, PLAYER_PICTURES, compileAgain, openRendererParts };

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

@@ -0,0 +1,176 @@
+import { ensureIndexInRange, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
+import { MEI_TERM_CAPACITY } from "../../../core/src/domain/optics/MeiDistortion.js";
+import { IDENTITY_MATRIX3 } from "../../../core/src/shared/math/Matrix3.js";
+import { aspectOfArea, planeHalfExtentOf } from "../../../core/src/domain/view/rectilinear.js";
+import { toThreeMatrix } from "./threeMatrix.js";
+import { CONVERSION_DEFINES, conversionUniforms } from "./conversionUniforms.js";
+import { Matrix3, Vector2, Vector3, Vector4 } from "three";
+var LENS_MEI = 0;
+var LENS_RADIAL_POLYNOMIAL = 1;
+/**
+* The constants the player's GLSL sources refer to, injected as preprocessor defines so that
+* this file is their only home; the lab adds its own.
+*/
+var SHADER_DEFINES = Object.fromEntries([
+	["MAX_LENSES", 2],
+	["LENS_MEI", LENS_MEI],
+	["LENS_RADIAL_POLYNOMIAL", LENS_RADIAL_POLYNOMIAL],
+	["MEI_RADIAL_TERMS", MEI_TERM_CAPACITY.radial],
+	["MEI_TANGENTIAL_ORDERS", MEI_TERM_CAPACITY.tangential],
+	["MEI_THIN_PRISM_ORDERS", MEI_TERM_CAPACITY.thinPrism],
+	...CONVERSION_DEFINES,
+	["SAMPLING_BILINEAR", 0],
+	["SAMPLING_TRILINEAR", 1],
+	["SAMPLING_SUPERSAMPLED", 2]
+]);
+function createRendererUniforms(setup, textures) {
+	const lenses = padded(setup.lenses, "a stitching setup has one or two lenses");
+	return {
+		...viewUniforms(setup),
+		...projectionUniforms(lenses),
+		...samplingUniforms(lenses),
+		...conversionUniforms(lenses),
+		uTexture0: { value: textures[0] ?? null },
+		uTexture1: { value: textures[1] ?? null }
+	};
+}
+function viewUniforms(setup) {
+	return {
+		uLensCount: { value: setup.lenses.length },
+		uViewRotation: { value: new Matrix3() },
+		uStabilization: { value: new Matrix3() },
+		uPlaneHalfExtent: { value: 1 },
+		uPictureAspect: { value: 1 },
+		uScreenArea: { value: Array.from({ length: 2 }, () => new Vector4(0, 0, 1, 1)) },
+		uFeather: { value: new Vector2(setup.feather.start, setup.feather.end) }
+	};
+}
+function projectionUniforms(lenses) {
+	const slots = lenses.map((lens) => slotOf(lens.projection));
+	return {
+		uLensRotation: { value: lenses.map((lens) => toThreeMatrix(lens.rotation)) },
+		uLensKind: { value: slots.map((slot) => slot.kind) },
+		uLensPrincipalPoint: { value: lenses.map((lens) => toVector2(lens.projection.principalPoint)) },
+		uLensFocal: { value: slots.map((slot) => slot.focal) },
+		uLensXi: { value: slots.map((slot) => slot.xi) },
+		uLensRadial: { value: slots.flatMap((slot) => slot.radial) },
+		uLensTangential: { value: slots.flatMap((slot) => slot.tangential) },
+		uLensThinPrism: { value: slots.flatMap((slot) => slot.thinPrism) },
+		uLensPolynomial: { value: slots.map((slot) => slot.polynomial) },
+		uLensHalfFov: { value: lenses.map((lens) => lens.halfFieldOfView) }
+	};
+}
+var NO_MEI_DISTORTION = {
+	radial: [],
+	tangential: [],
+	thinPrism: []
+};
+/**
+* Exhaustive over the projection kinds: a new kind does not compile until it is packed.
+*/
+function slotOf(projection) {
+	switch (projection.kind) {
+		case "mei": return {
+			kind: LENS_MEI,
+			focal: new Vector2(...projection.focal),
+			xi: projection.xi,
+			...meiTermSlots(projection.distortion),
+			polynomial: new Vector4()
+		};
+		case "radial-polynomial": return {
+			kind: LENS_RADIAL_POLYNOMIAL,
+			focal: new Vector2(),
+			xi: 0,
+			...meiTermSlots(NO_MEI_DISTORTION),
+			polynomial: new Vector4(...projection.coefficients)
+		};
+	}
+}
+function meiTermSlots(distortion) {
+	return {
+		radial: fittedToCapacity(distortion.radial, MEI_TERM_CAPACITY.radial, () => 0),
+		tangential: fittedToCapacity(distortion.tangential.map((pair) => new Vector2(pair.p1, pair.p2)), MEI_TERM_CAPACITY.tangential, () => new Vector2()),
+		thinPrism: fittedToCapacity(distortion.thinPrism.map((term) => new Vector2(term.x, term.y)), MEI_TERM_CAPACITY.thinPrism, () => new Vector2())
+	};
+}
+/**
+* The terms in the room the shader holds for their family, the rest of it zero; more terms than
+* it holds are a defect of the model that made them.
+*/
+function fittedToCapacity(terms, capacity, zero) {
+	ensureInvariant(terms.length <= capacity, `a Mei lens has ${terms.length} terms of a family the shader holds ${capacity} of`);
+	return Array.from({ length: capacity }, (_unused, index) => terms[index] ?? zero());
+}
+function samplingUniforms(lenses) {
+	return {
+		uLensWindow: { value: lenses.map((lens) => new Vector4(lens.window.x, lens.window.y, lens.window.width, lens.window.height)) },
+		uLensRegion: { value: lenses.map((lens) => new Vector4(lens.region.x, lens.region.y, lens.region.width, lens.region.height)) },
+		uLensTexture: { value: lenses.map((lens) => lens.frameSlot) },
+		uLensGain: { value: lenses.map(() => new Vector3(1, 1, 1)) },
+		uSampling: { value: 0 }
+	};
+}
+function applyShaderSampling(uniforms, strategy) {
+	uniforms.uSampling.value = strategy.shaderSampling;
+}
+function applyStabilization(uniforms, rotation) {
+	uniforms.uStabilization.value = toThreeMatrix(rotation);
+}
+/**
+* Sets one lens's per-channel multiplier; a lens the setup does not have is a defect.
+*/
+function applyLensGain(uniforms, lensIndex, gain) {
+	ensureIndexInRange(lensIndex, uniforms.uLensCount.value, "lens");
+	uniforms.uLensGain.value[lensIndex]?.set(...gain);
+}
+var NEUTRAL = {
+	rotation: IDENTITY_MATRIX3,
+	planeHalfExtent: 1,
+	pictureAspect: 1
+};
+/**
+* Sets the uniforms `picture` is drawn from, on a viewport `viewportAspect` wide per unit of
+* height.
+*/
+function applyPicture(uniforms, picture, viewportAspect) {
+	const values = valuesOf(picture, viewportAspect);
+	uniforms.uViewRotation.value = toThreeMatrix(values.rotation);
+	uniforms.uPlaneHalfExtent.value = values.planeHalfExtent;
+	uniforms.uPictureAspect.value = values.pictureAspect;
+	uniforms.uScreenArea.value = padded(values.areas, "a picture fills one area per lens at most").map((area) => toVector4(area));
+}
+function valuesOf(picture, viewportAspect) {
+	switch (picture.kind) {
+		case "rectilinear": return {
+			rotation: picture.rotation,
+			planeHalfExtent: planeHalfExtentOf(picture.fieldOfView),
+			pictureAspect: aspectOfArea(picture.area, viewportAspect),
+			areas: [picture.area]
+		};
+		case "equirectangular": return {
+			...NEUTRAL,
+			rotation: picture.rotation,
+			areas: [picture.area]
+		};
+		case "lens-tiles": return {
+			...NEUTRAL,
+			areas: picture.tiles
+		};
+	}
+}
+function toVector4(area) {
+	return new Vector4(area.x, area.y, area.width, area.height);
+}
+function toVector2(point) {
+	return new Vector2(point.x, point.y);
+}
+/**
+* Uniform arrays have a fixed length; unused slots repeat the last entry and are never read.
+*/
+function padded(entries, expectation) {
+	const last = entries.at(-1);
+	ensureInvariant(last !== void 0 && entries.length <= 2, expectation);
+	return Array.from({ length: 2 }, (_unused, index) => entries[index] ?? last);
+}
+//#endregion
+export { SHADER_DEFINES, applyLensGain, applyPicture, applyShaderSampling, applyStabilization, createRendererUniforms };

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

@@ -0,0 +1,26 @@
+import { LinearFilter, LinearMipmapLinearFilter } from "three";
+/**
+* The record keyed by the quality refuses to compile until every tier has a strategy.
+*/
+var SAMPLING_STRATEGIES = {
+	fast: {
+		minFilter: LinearFilter,
+		generateMipmaps: false,
+		anisotropy: 1,
+		shaderSampling: 0
+	},
+	balanced: {
+		minFilter: LinearMipmapLinearFilter,
+		generateMipmaps: true,
+		anisotropy: 4,
+		shaderSampling: 1
+	},
+	high: {
+		minFilter: LinearMipmapLinearFilter,
+		generateMipmaps: true,
+		anisotropy: 8,
+		shaderSampling: 2
+	}
+};
+//#endregion
+export { SAMPLING_STRATEGIES };

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

@@ -0,0 +1,20 @@
+import { Vector4 } from "three";
+//#region ../../packages/adapters/three/src/scissorBox.ts
+/**
+* Pixels the box reaches past the area on each side, so that rounding never cuts a pixel the
+* area holds; the shader decides those.
+*/
+var MARGIN_PIXELS = 1;
+/**
+* The box of the drawing buffer a pass is drawn within, in device pixels from the bottom-left
+* corner as three's scissor takes it, around an area of the viewport given from the top-left.
+*/
+function scissorBoxOf(area, buffer) {
+	const left = Math.max(Math.floor(area.x * buffer.width) - MARGIN_PIXELS, 0);
+	const right = Math.min(Math.ceil((area.x + area.width) * buffer.width) + MARGIN_PIXELS, buffer.width);
+	const top = Math.max(Math.floor(area.y * buffer.height) - MARGIN_PIXELS, 0);
+	const bottom = Math.min(Math.ceil((area.y + area.height) * buffer.height) + MARGIN_PIXELS, buffer.height);
+	return new Vector4(left, buffer.height - bottom, right - left, bottom - top);
+}
+//#endregion
+export { scissorBoxOf };

package/dist/packages/adapters/three/src/seamMeter/SeamMeterPass.js

@@ -0,0 +1,85 @@
+import { createFullscreenTriangle, createPassMaterial, programOf } from "../fullscreenPass.js";
+import { compileAndProve } from "../compileAndProve.js";
+import { SEAM_ANALYSIS } from "../shaderPrograms.js";
+import { rowMeansOf } from "./rowMeans.js";
+import { renderInto } from "../renderInto.js";
+import { Camera, Mesh, Scene, WebGLRenderTarget } from "three";
+//#region ../../packages/adapters/three/src/seamMeter/SeamMeterPass.ts
+/**
+* Samples taken around the seam ring per lens: enough to average out content, few enough that
+* the read-back is negligible.
+*/
+var SEAM_SAMPLES = 64;
+/**
+* SeamMeter over the GPU: renders what each lens sees along the seam ring into one row of a tiny
+* target and reads the rows back, sharing the stitch's uniforms so it always looks at the frames
+* on screen. Compiled and proven when created, so a broken shader fails there and not
+* mid-playback.
+*/
+var SeamMeterPass = class {
+	renderer;
+	lensCount;
+	target = new WebGLRenderTarget(SEAM_SAMPLES, 2, {
+		depthBuffer: false,
+		stencilBuffer: false
+	});
+	pixels = new Uint8Array(SEAM_SAMPLES * 2 * 4);
+	camera = new Camera();
+	scene = new Scene();
+	material;
+	geometry = createFullscreenTriangle();
+	isDisposed = false;
+	constructor(renderer, uniforms, lensCount) {
+		this.renderer = renderer;
+		this.lensCount = lensCount;
+		this.material = createPassMaterial(uniforms, programOf(SEAM_ANALYSIS));
+		this.scene.add(new Mesh(this.geometry, this.material));
+		try {
+			this.prove();
+		} catch (error) {
+			this.dispose();
+			throw error;
+		}
+	}
+	/**
+	* Compiles and proves the meter's program now, rather than at its first measurement.
+	*/
+	prove() {
+		compileAndProve(this.renderer, this.scene, this.camera);
+	}
+	/**
+	* Mean colour (0..1) each lens shows along the seam where they can be compared, or undefined
+	* when they cannot be anywhere.
+	*/
+	async measure() {
+		try {
+			await this.readSeam();
+		} catch (error) {
+			if (this.isDisposed || this.renderer.getContext().isContextLost()) return void 0;
+			throw error;
+		}
+		return this.isDisposed ? void 0 : rowMeansOf(this.pixels, SEAM_SAMPLES, this.lensCount);
+	}
+	dispose() {
+		if (this.isDisposed) return;
+		this.isDisposed = true;
+		this.target.dispose();
+		this.material.dispose();
+		this.geometry.dispose();
+	}
+	/**
+	* Renders the seam rows into the meter's target, the renderer's own target restored however the
+	* drawing ends.
+	*/
+	draw() {
+		renderInto(this.renderer, this.target, () => {
+			this.renderer.render(this.scene, this.camera);
+		});
+	}
+	async readSeam() {
+		this.draw();
+		await this.renderer.readRenderTargetPixelsAsync(this.target, 0, 0, SEAM_SAMPLES, 2, this.pixels);
+	}
+};
+//#endregion
+export { SeamMeterPass };

package/dist/packages/adapters/three/src/seamMeter/rowMeans.js

@@ -0,0 +1,42 @@
+var CHANNEL_MAX = 255;
+var ALPHA = 3;
+/**
+* A channel at or above this level (of 255) is blown out, or nearly: the lens's exposure no
+* longer scales it, so its ratio to the other lens says nothing about their exposures.
+*/
+var BLOWN_OUT_LEVEL = 250;
+/**
+* Mean RGB (0..1) of each row of an RGBA8 image, one row per lens and one column per direction
+* along the seam, over the directions every row images (non-zero alpha) and none shows blown out:
+* only there do the lenses' colours differ by their exposures. Undefined when no such direction
+* is left, because then there is nothing to match.
+*/
+function rowMeansOf(pixels, width, rowCount) {
+	const rows = Array.from({ length: rowCount }, (_, row) => pixels.subarray(row * width * 4, (row + 1) * width * 4));
+	const columns = Array.from({ length: width }, (_, column) => column * 4).filter((offset) => rows.every((row) => isComparable(row, offset)));
+	return columns.length === 0 ? void 0 : rows.map((row) => meanOf(row, columns));
+}
+function isComparable(row, offset) {
+	const texel = row.subarray(offset, offset + 4);
+	return (texel[ALPHA] ?? 0) !== 0 && texel.subarray(0, ALPHA).every((channel) => channel < BLOWN_OUT_LEVEL);
+}
+function meanOf(row, columns) {
+	const sum = [
+		0,
+		0,
+		0
+	];
+	for (const offset of columns) {
+		sum[0] += row[offset] ?? 0;
+		sum[1] += row[offset + 1] ?? 0;
+		sum[2] += row[offset + 2] ?? 0;
+	}
+	const scale = columns.length * CHANNEL_MAX;
+	return [
+		sum[0] / scale,
+		sum[1] / scale,
+		sum[2] / scale
+	];
+}
+//#endregion
+export { rowMeansOf };