@bubo-squared/gyroview 0.1.0

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

@@ -0,0 +1,274 @@
+import { GyroViewError, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
+import { DEFAULT_PICTURE_QUALITY } from "../../../core/src/domain/view/PictureQuality.js";
+import { DEFAULT_VIEW_MODE } from "../../../core/src/domain/view/ViewMode.js";
+import { aspectOf } from "../../../core/src/domain/view/screenLayout.js";
+import { DEFAULT_FRAMING } from "../../../core/src/domain/view/Framing.js";
+import { viewModeRulesFor } from "../../../core/src/domain/view/viewModes.js";
+import "../../../core/src/index.js";
+import { SAMPLING_STRATEGIES } from "./samplingStrategies.js";
+import { applyLensGain, applyPicture, applyShaderSampling, applyStabilization, createRendererUniforms } from "./rendererUniforms.js";
+import { createFullscreenTriangle } from "./fullscreenPass.js";
+import { createRenderer } from "./webglRenderer.js";
+import { SeamMeterPass } from "./seamMeter/SeamMeterPass.js";
+import { applyTextureFilters, createLensTextures } from "./lensTextures.js";
+import { PLAYER_SHADERS, compilePictureMaterials, createPictureMaterials, disposePictureMaterials } from "./pictureMaterials.js";
+import { Camera, Mesh, Scene } from "three";
+//#region ../../packages/adapters/three/src/ThreeFrameRenderer.ts
+var PLAYER_PICTURES = {
+	shaders: PLAYER_SHADERS,
+	uniforms: {}
+};
+/**
+* PictureRenderer over Three.js: uploads each lens frame to a texture and draws one fullscreen pass
+* per frame, laid out on the viewport as the view mode's picture for the framing says: the
+* stitched sphere through `stitch.frag.glsl`, turned by the view and stabilization rotations, or
+* each lens image in a tile of its own.
+*/
+var ThreeFrameRenderer = class {
+	parts;
+	canvas;
+	framing = DEFAULT_FRAMING;
+	viewMode = DEFAULT_VIEW_MODE;
+	/**
+	* False until the first pair arrives. The textures then hold the pair on screen, which the
+	* session keeps open until it presents the next one.
+	*/
+	hasFrames = false;
+	isDisposed = false;
+	meters = /* @__PURE__ */ new Set();
+	constructor(parts, canvas) {
+		this.parts = parts;
+		this.canvas = canvas;
+		this.applyFraming();
+		canvas.addEventListener("webglcontextrestored", this.onContextRestored);
+	}
+	static create(canvas, setup, options = {}) {
+		const opening = {
+			options,
+			pictures: PLAYER_PICTURES
+		};
+		return new this(this.openParts(canvas, setup, opening), canvas);
+	}
+	/**
+	* The context, textures, uniforms and compiled programs of a renderer that draws with the
+	* given pictures.
+	*/
+	static openParts(canvas, setup, opening) {
+		ensureDrawable(setup);
+		const renderer = createRenderer(canvas, opening.options);
+		try {
+			return assembleParts(renderer, setup, opening.pictures);
+		} catch (error) {
+			renderer.dispose();
+			throw error;
+		}
+	}
+	get lensCount() {
+		return this.parts.lensCount;
+	}
+	setFraming(framing) {
+		this.ensureLive();
+		this.framing = framing;
+		this.applyFraming();
+		this.render();
+	}
+	setViewMode(mode) {
+		this.ensureLive();
+		this.viewMode = mode;
+		this.applyFraming();
+		this.render();
+	}
+	/**
+	* The frames standing on screen are uploaded again with the new filters and mip chain, so the
+	* change shows at once, even while paused.
+	*/
+	setQuality(quality) {
+		this.ensureLive();
+		const strategy = SAMPLING_STRATEGIES[quality];
+		for (const texture of this.parts.textures) {
+			applyTextureFilters(texture, strategy);
+			if (this.hasFrames) texture.needsUpdate = true;
+		}
+		applyShaderSampling(this.parts.uniforms, strategy);
+		this.render();
+	}
+	setLensGains(gains) {
+		this.ensureLive();
+		for (const [lensIndex, gain] of gains.entries()) applyLensGain(this.parts.uniforms, lensIndex, gain);
+		this.render();
+	}
+	/**
+	* The meter leaves this renderer's list when disposed; the renderer disposes those still live
+	* when it goes, since they share its context and uniforms.
+	*/
+	createSeamMeter() {
+		this.ensureLive();
+		const pass = new SeamMeterPass(this.parts.renderer, this.parts.uniforms, this.parts.lensCount);
+		return this.tracked({
+			measure: () => pass.measure(),
+			dispose: () => {
+				pass.dispose();
+			}
+		});
+	}
+	/**
+	* Turns the whole picture: the stabilized frame the viewer looks around in, into the body.
+	* Does not redraw by itself: the stabilizing sink calls it right before presenting a pair.
+	*/
+	setStabilization(rotation) {
+		this.ensureLive();
+		applyStabilization(this.parts.uniforms, rotation);
+	}
+	present(presentation) {
+		this.ensureLive();
+		const { frames } = presentation.pair;
+		ensureInvariant(frames.length === this.parts.textures.length, `a pair of ${frames.length} frames does not fit ${this.parts.textures.length} lens textures`);
+		for (const [index, texture] of this.parts.textures.entries()) {
+			const frame = frames[index];
+			if (frame) texture.setFrame(frame.handle);
+		}
+		this.hasFrames = true;
+		this.render();
+	}
+	/**
+	* Matches the drawing buffer to a new element size, in device pixels.
+	*/
+	resize(size) {
+		this.ensureLive();
+		this.parts.renderer.setSize(size.width, size.height, false);
+		this.applyFraming();
+		this.render();
+	}
+	dispose() {
+		if (this.isDisposed) return;
+		this.isDisposed = true;
+		this.canvas.removeEventListener("webglcontextrestored", this.onContextRestored);
+		for (const meter of this.meters) meter.dispose();
+		this.parts.seamProof.dispose();
+		for (const texture of this.parts.textures) texture.dispose();
+		disposePictureMaterials(this.parts.materials);
+		this.parts.pass.geometry.dispose();
+		this.parts.renderer.dispose();
+	}
+	/**
+	* The WebGL renderer and the shared uniforms, for a subclass's own passes and settings.
+	*/
+	get webgl() {
+		return this.parts.renderer;
+	}
+	get uniforms() {
+		return this.parts.uniforms;
+	}
+	/**
+	* A meter over a pass that shares this renderer's context, which the renderer disposes with
+	* itself unless it is disposed first.
+	*/
+	tracked(meter) {
+		const kept = {
+			...meter,
+			dispose: () => {
+				this.meters.delete(kept);
+				meter.dispose();
+			}
+		};
+		this.meters.add(kept);
+		return kept;
+	}
+	render() {
+		if (!this.hasFrames) return;
+		this.parts.renderer.render(this.parts.scene, this.parts.camera);
+	}
+	ensureLive() {
+		ensureInvariant(!this.isDisposed, "the renderer has been disposed");
+	}
+	/**
+	* Three.js builds its state anew on a restored context but draws nothing: a paused picture
+	* (iOS drops the context of a tab in the background) comes back only through a redraw, which
+	* uploads the frames on screen again.
+	*/
+	onContextRestored = () => {
+		this.render();
+	};
+	/**
+	* Asks the view mode what to draw for the framing on this canvas, and switches to that
+	* picture's program.
+	*/
+	applyFraming() {
+		const viewport = {
+			width: this.canvas.width,
+			height: this.canvas.height
+		};
+		const picture = viewModeRulesFor(this.viewMode).picture(this.framing, {
+			viewport,
+			lensCount: this.parts.lensCount
+		});
+		this.parts.pass.material = this.parts.materials[picture.kind];
+		applyPicture(this.parts.uniforms, picture, aspectOf(viewport));
+	}
+};
+/**
+* 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) {
+	const strategy = SAMPLING_STRATEGIES[DEFAULT_PICTURE_QUALITY];
+	const textures = createLensTextures(setup.frameSlotCount, strategy);
+	const uniforms = createRendererUniforms(setup, textures);
+	applyShaderSampling(uniforms, strategy);
+	return {
+		textures,
+		uniforms,
+		materials: createPictureMaterials({
+			...uniforms,
+			...pictures.uniforms
+		}, pictures.shaders)
+	};
+}
+function assembleParts(renderer, setup, pictures) {
+	const { textures, uniforms, materials } = sharedParts(setup, pictures);
+	const pass = new Mesh(createFullscreenTriangle(), materials.rectilinear);
+	const seamProof = provenSeamMeter(renderer, {
+		pass,
+		materials,
+		textures,
+		uniforms
+	});
+	const scene = new Scene();
+	scene.add(pass);
+	return {
+		renderer,
+		scene,
+		camera: new Camera(),
+		pass,
+		materials,
+		textures,
+		uniforms,
+		lensCount: setup.lenses.length,
+		seamProof
+	};
+}
+/**
+* Compiles and proves every picture program, then opens the seam meter, which proves its own
+* (gain matching asks for one at every load); what was built goes if a program fails.
+*/
+function provenSeamMeter(renderer, built) {
+	const { pass, materials, textures, uniforms } = built;
+	try {
+		compilePictureMaterials(renderer, pass.geometry, materials);
+		return new SeamMeterPass(renderer, uniforms, uniforms.uLensCount.value);
+	} catch (error) {
+		disposePictureMaterials(materials);
+		pass.geometry.dispose();
+		for (const texture of textures) texture.dispose();
+		throw error;
+	}
+}
+//#endregion
+export { ThreeFrameRenderer };

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

@@ -0,0 +1,14 @@
+//#region ../../packages/adapters/three/src/compileAndProve.ts
+/**
+* Compiles the programs `scene` needs and asks every program the renderer holds for its uniforms.
+* Three checks a program's link at its first use, and that request is one, so a shader the GPU
+* refuses fails here through the renderer's shader-error hook without a draw (which costs a
+* software renderer hundreds of milliseconds on the main thread).
+*/
+function compileAndProve(renderer, scene, camera) {
+	renderer.compile(scene, camera);
+	const programs = renderer.info.programs ?? [];
+	for (const program of programs) program.getUniforms();
+}
+//#endregion
+export { compileAndProve };

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/index.js

@@ -0,0 +1,2 @@
+import { ThreeFrameRenderer } from "./ThreeFrameRenderer.js";
+export { ThreeFrameRenderer };

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

@@ -0,0 +1,25 @@
+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;
+}
+//#endregion
+export { applyTextureFilters, createLensTextures };

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/rendererUniforms.js

@@ -0,0 +1,157 @@
+import { ensureIndexInRange, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
+import { IDENTITY_MATRIX3 } from "../../../core/src/shared/math/Matrix3.js";
+import { aspectOfArea, planeHalfExtentOf } from "../../../core/src/domain/view/rectilinear.js";
+import "../../../core/src/index.js";
+import "./samplingStrategies.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],
+	["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),
+		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.map((slot) => slot.radial) },
+		uLensTangential: { value: slots.map((slot) => slot.tangential) },
+		uLensPolynomial: { value: slots.map((slot) => slot.polynomial) },
+		uLensHalfFov: { value: lenses.map((lens) => lens.halfFieldOfView) }
+	};
+}
+/**
+* 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,
+			radial: new Vector3(...projection.radial),
+			tangential: new Vector2(...projection.tangential),
+			polynomial: new Vector4()
+		};
+		case "radial-polynomial": return {
+			kind: LENS_RADIAL_POLYNOMIAL,
+			focal: new Vector2(),
+			xi: 0,
+			radial: new Vector3(),
+			tangential: new Vector2(),
+			polynomial: new Vector4(...projection.coefficients)
+		};
+	}
+}
+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);
+}
+/**
+* Row-major core matrix into a three matrix, whose `set` takes rows too.
+*/
+function toThreeMatrix(m) {
+	return new Matrix3().set(...m);
+}
+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/seamMeter/SeamMeterPass.js

@@ -0,0 +1,79 @@
+import "../rendererUniforms.js";
+import { createFullscreenTriangle, createPassMaterial, programOf } from "../fullscreenPass.js";
+import { rowMeansOf } from "./rowMeans.js";
+import { compileAndProve } from "../compileAndProve.js";
+import { renderInto } from "../renderInto.js";
+import { SEAM_ANALYSIS } from "../shaderPrograms.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 {
+			compileAndProve(renderer, this.scene, this.camera);
+		} catch (error) {
+			this.dispose();
+			throw error;
+		}
+	}
+	/**
+	* Mean colour (0..1) each lens shows along the seam, or undefined when a lens images none of it.
+	*/
+	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 };