@aura3d/rendering 1.4.0 → 1.4.2

package/src/SpaceEnvironmentFixtures.ts

@@ -1,200 +0,0 @@
-export interface SpaceEnvironmentStar {
-  readonly x: number;
-  readonly y: number;
-  readonly depth: number;
-  readonly size: number;
-  readonly speed: number;
-  readonly brightness: number;
-}
-
-export interface SpaceEnvironmentNebula {
-  readonly x: number;
-  readonly y: number;
-  readonly radius: number;
-  readonly color: readonly [number, number, number];
-  readonly alpha: number;
-  readonly drift: number;
-}
-
-export interface SpaceEnvironmentDustParticle {
-  readonly x: number;
-  readonly y: number;
-  readonly velocityX: number;
-  readonly velocityY: number;
-  readonly size: number;
-  readonly alpha: number;
-}
-
-export interface SpaceEnvironmentFixture {
-  readonly id: "external-parity-old-branch-space-environment";
-  readonly source: "origin-master-space-environment-adapted";
-  readonly sourceFiles: readonly string[];
-  readonly width: number;
-  readonly height: number;
-  readonly elapsedSeconds: number;
-  readonly layerScroll: {
-    readonly distantStars: number;
-    readonly foregroundStars: number;
-  };
-  readonly stars: readonly SpaceEnvironmentStar[];
-  readonly nebulae: readonly SpaceEnvironmentNebula[];
-  readonly dust: readonly SpaceEnvironmentDustParticle[];
-  readonly starCount: number;
-  readonly nebulaCount: number;
-  readonly dustCount: number;
-  readonly visibleStarCount: number;
-  readonly averageStarBrightness: number;
-  readonly nebulaCoverage: number;
-  readonly dustAlpha: number;
-  readonly blockedClaims: readonly string[];
-  readonly claimBoundary: string;
-  readonly hash: string;
-}
-
-const sourceFiles = [
-  "origin/master:examples/space-shooter/src/SpaceEnvironment.ts",
-  "origin/master:src/assets/ProceduralTextures.ts"
-] as const;
-
-const blockedClaims = [
-  "3D volumetric nebula rendering",
-  "HDR skybox environment lighting",
-  "production space-scene asset pack",
-  "Unity VFX Graph background parity",
-  "Unreal Niagara background parity"
-] as const;
-
-const nebulaPalette = [
-  [0.42, 0.18, 0.76],
-  [0.12, 0.42, 0.88],
-  [0.78, 0.18, 0.48],
-  [0.1, 0.68, 0.72],
-  [0.86, 0.46, 0.72]
-] as const;
-
-export function sampleSpaceEnvironmentFixture(options: {
-  readonly width?: number;
-  readonly height?: number;
-  readonly elapsedSeconds?: number;
-  readonly seed?: number;
-  readonly starCount?: number;
-  readonly nebulaCount?: number;
-  readonly dustCount?: number;
-} = {}): SpaceEnvironmentFixture {
-  const width = positiveInteger(options.width ?? 960, "width");
-  const height = positiveInteger(options.height ?? 540, "height");
-  const elapsedSeconds = finiteNonNegative(options.elapsedSeconds ?? 0, "elapsedSeconds");
-  const seed = positiveInteger(options.seed ?? 0x51ace, "seed");
-  const starCount = positiveInteger(options.starCount ?? 72, "starCount");
-  const nebulaCount = positiveInteger(options.nebulaCount ?? 5, "nebulaCount");
-  const dustCount = positiveInteger(options.dustCount ?? 96, "dustCount");
-  const stars = Array.from({ length: starCount }, (_, index) => sampleStar(seed, index, width, height, elapsedSeconds));
-  const nebulae = Array.from({ length: nebulaCount }, (_, index) => sampleNebula(seed, index, width, height, elapsedSeconds));
-  const dust = Array.from({ length: dustCount }, (_, index) => sampleDust(seed, index, width, height, elapsedSeconds));
-  const visibleStarCount = stars.filter((star) => star.x >= 0 && star.x <= width && star.y >= 0 && star.y <= height).length;
-  const averageStarBrightness = stars.reduce((sum, star) => sum + star.brightness, 0) / stars.length;
-  const nebulaCoverage = nebulae.reduce((sum, nebula) => sum + Math.PI * nebula.radius * nebula.radius, 0) / (width * height);
-  const dustAlpha = dust.reduce((sum, particle) => sum + particle.alpha, 0) / dust.length;
-  const fixtureWithoutHash = {
-    id: "external-parity-old-branch-space-environment" as const,
-    source: "origin-master-space-environment-adapted" as const,
-    sourceFiles,
-    width,
-    height,
-    elapsedSeconds: Number(elapsedSeconds.toFixed(4)),
-    layerScroll: {
-      distantStars: Number(((elapsedSeconds * 10) % height).toFixed(3)),
-      foregroundStars: Number(((elapsedSeconds * 25) % height).toFixed(3))
-    },
-    stars,
-    nebulae,
-    dust,
-    starCount,
-    nebulaCount,
-    dustCount,
-    visibleStarCount,
-    averageStarBrightness: Number(averageStarBrightness.toFixed(4)),
-    nebulaCoverage: Number(nebulaCoverage.toFixed(4)),
-    dustAlpha: Number(dustAlpha.toFixed(4)),
-    blockedClaims,
-    claimBoundary: "This fixture adapts old scrolling starfield, nebula, and dust concepts into deterministic 2D/background evidence. It does not claim volumetric space rendering, HDR skybox lighting, or Unity/Unreal VFX parity."
-  };
-  return {
-    ...fixtureWithoutHash,
-    hash: stableHash(JSON.stringify(fixtureWithoutHash))
-  };
-}
-
-function sampleStar(seed: number, index: number, width: number, height: number, elapsedSeconds: number): SpaceEnvironmentStar {
-  const depth = hash01(seed, index, 11);
-  const speed = 20 + hash01(seed, index, 23) * 80;
-  const rawY = hash01(seed, index, 37) * height + elapsedSeconds * speed;
-  const twinkle = 0.8 + Math.sin(elapsedSeconds * speed * 0.08 + hash01(seed, index, 41) * Math.PI * 2) * 0.2;
-  return {
-    x: Number((hash01(seed, index, 17) * width).toFixed(3)),
-    y: Number((rawY % height).toFixed(3)),
-    depth: Number(depth.toFixed(4)),
-    size: Number((0.8 + depth * 2.2).toFixed(3)),
-    speed: Number(speed.toFixed(3)),
-    brightness: Number(((0.52 + depth * 0.48) * twinkle).toFixed(4))
-  };
-}
-
-function sampleNebula(seed: number, index: number, width: number, height: number, elapsedSeconds: number): SpaceEnvironmentNebula {
-  const radius = width * (0.12 + hash01(seed, index, 53) * 0.18);
-  const drift = (hash01(seed, index, 67) - 0.5) * 10;
-  const rawY = hash01(seed, index, 79) * height + elapsedSeconds * drift;
-  const palette = nebulaPalette[index % nebulaPalette.length] ?? nebulaPalette[0];
-  return {
-    x: Number((hash01(seed, index, 83) * width).toFixed(3)),
-    y: Number((((rawY % height) + height) % height).toFixed(3)),
-    radius: Number(radius.toFixed(3)),
-    color: palette,
-    alpha: Number((0.18 + hash01(seed, index, 97) * 0.22).toFixed(4)),
-    drift: Number(drift.toFixed(3))
-  };
-}
-
-function sampleDust(seed: number, index: number, width: number, height: number, elapsedSeconds: number): SpaceEnvironmentDustParticle {
-  const velocityX = (hash01(seed, index, 109) - 0.5) * 20;
-  const velocityY = 30 + hash01(seed, index, 127) * 50;
-  const rawX = hash01(seed, index, 131) * width + elapsedSeconds * velocityX;
-  const rawY = hash01(seed, index, 149) * height + elapsedSeconds * velocityY;
-  return {
-    x: Number((((rawX % width) + width) % width).toFixed(3)),
-    y: Number((rawY % height).toFixed(3)),
-    velocityX: Number(velocityX.toFixed(3)),
-    velocityY: Number(velocityY.toFixed(3)),
-    size: Number((0.4 + hash01(seed, index, 157) * 1.3).toFixed(3)),
-    alpha: Number((0.28 + hash01(seed, index, 163) * 0.38).toFixed(4))
-  };
-}
-
-function hash01(seed: number, index: number, salt: number): number {
-  let hash = (seed ^ Math.imul(index + 1, 0x9e3779b1) ^ Math.imul(salt + 1, 0x85ebca6b)) >>> 0;
-  hash ^= hash >>> 16;
-  hash = Math.imul(hash, 0x7feb352d) >>> 0;
-  hash ^= hash >>> 15;
-  hash = Math.imul(hash, 0x846ca68b) >>> 0;
-  hash ^= hash >>> 16;
-  return (hash >>> 0) / 0xffffffff;
-}
-
-function positiveInteger(value: number, name: string): number {
-  if (!Number.isInteger(value) || value <= 0) throw new RangeError(`Space environment ${name} must be a positive integer.`);
-  return value;
-}
-
-function finiteNonNegative(value: number, name: string): number {
-  if (!Number.isFinite(value) || value < 0) throw new RangeError(`Space environment ${name} must be finite and non-negative.`);
-  return value;
-}
-
-function stableHash(value: string): string {
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}

package/src/SpriteGeometry.ts

@@ -1,21 +0,0 @@
-import { Geometry } from "./Geometry";
-import { IndexBuffer } from "./IndexBuffer";
-import { VertexBuffer } from "./VertexBuffer";
-import { VertexFormat } from "./VertexFormat";
-
-export function createSpriteQuadGeometry(): Geometry {
-  const vertices = new VertexBuffer(VertexFormat.P3N3T2, 4);
-  vertices.setAttribute(0, "position", [-0.5, -0.5, 0]);
-  vertices.setAttribute(0, "normal", [0, 0, 1]);
-  vertices.setAttribute(0, "uv", [0, 1]);
-  vertices.setAttribute(1, "position", [0.5, -0.5, 0]);
-  vertices.setAttribute(1, "normal", [0, 0, 1]);
-  vertices.setAttribute(1, "uv", [1, 1]);
-  vertices.setAttribute(2, "position", [0.5, 0.5, 0]);
-  vertices.setAttribute(2, "normal", [0, 0, 1]);
-  vertices.setAttribute(2, "uv", [1, 0]);
-  vertices.setAttribute(3, "position", [-0.5, 0.5, 0]);
-  vertices.setAttribute(3, "normal", [0, 0, 1]);
-  vertices.setAttribute(3, "uv", [0, 0]);
-  return new Geometry(vertices, new IndexBuffer([0, 1, 2, 0, 2, 3], 4));
-}

package/src/StereoCameraRig.ts

@@ -1,127 +0,0 @@
-import { invertMat4, multiplyMat4, type Mat4, type Vec3 } from "@aura3d/scene";
-import type { PerspectiveCameraFrame } from "./CameraFraming";
-
-export type StereoEye = "left" | "right";
-export type StereoLayout = "side-by-side" | "over-under";
-
-export interface StereoViewport {
-  readonly x: number;
-  readonly y: number;
-  readonly width: number;
-  readonly height: number;
-}
-
-export interface StereoCameraRigOptions {
-  readonly frame: Pick<PerspectiveCameraFrame, "cameraPosition" | "near" | "projectionMatrix" | "viewMatrix">;
-  readonly viewport: StereoViewport;
-  readonly eyeSeparation?: number;
-  readonly convergenceDistance?: number;
-  readonly layout?: StereoLayout;
-}
-
-export interface StereoEyeView {
-  readonly eye: StereoEye;
-  readonly eyeOffset: number;
-  readonly cameraPosition: Vec3;
-  readonly viewport: StereoViewport;
-  readonly viewMatrix: Mat4;
-  readonly projectionMatrix: Mat4;
-  readonly viewProjectionMatrix: Mat4;
-}
-
-export interface StereoCameraRig {
-  readonly layout: StereoLayout;
-  readonly eyeSeparation: number;
-  readonly convergenceDistance: number;
-  readonly views: readonly [StereoEyeView, StereoEyeView];
-}
-
-export function createStereoCameraRig(options: StereoCameraRigOptions): StereoCameraRig {
-  validateViewport(options.viewport);
-  const eyeSeparation = options.eyeSeparation ?? 0.064;
-  const convergenceDistance = options.convergenceDistance ?? 10;
-  const layout = options.layout ?? "side-by-side";
-  if (!Number.isFinite(eyeSeparation) || eyeSeparation <= 0 || eyeSeparation > 1) {
-    throw new RangeError("Stereo eyeSeparation must be finite and in (0, 1].");
-  }
-  if (!Number.isFinite(convergenceDistance) || convergenceDistance <= options.frame.near) {
-    throw new RangeError("Stereo convergenceDistance must be finite and greater than the near plane.");
-  }
-  const half = eyeSeparation / 2;
-  const left = createEyeView("left", -half, options, layout, convergenceDistance);
-  const right = createEyeView("right", half, options, layout, convergenceDistance);
-  return {
-    layout,
-    eyeSeparation,
-    convergenceDistance,
-    views: [left, right]
-  };
-}
-
-function createEyeView(
-  eye: StereoEye,
-  eyeOffset: number,
-  options: StereoCameraRigOptions,
-  layout: StereoLayout,
-  convergenceDistance: number
-): StereoEyeView {
-  const viewMatrix = multiplyMat4(translationMat4(-eyeOffset, 0, 0), options.frame.viewMatrix as Mat4);
-  const projectionMatrix = offsetProjectionForConvergence(options.frame.projectionMatrix as Mat4, eyeOffset, options.frame.near, convergenceDistance);
-  return {
-    eye,
-    eyeOffset,
-    cameraPosition: offsetCameraPosition(options.frame.viewMatrix as Mat4, options.frame.cameraPosition, eyeOffset),
-    viewport: eyeViewport(eye, options.viewport, layout),
-    viewMatrix,
-    projectionMatrix,
-    viewProjectionMatrix: multiplyMat4(projectionMatrix, viewMatrix)
-  };
-}
-
-function offsetProjectionForConvergence(projection: Mat4, eyeOffset: number, near: number, convergenceDistance: number): Mat4 {
-  const result = [...projection] as Mat4;
-  result[8] = (result[8] ?? 0) + eyeOffset * near / convergenceDistance;
-  return result;
-}
-
-function offsetCameraPosition(viewMatrix: Mat4, cameraPosition: readonly [number, number, number], eyeOffset: number): Vec3 {
-  const inverseView = invertMat4(viewMatrix);
-  const right: Vec3 = [inverseView[0], inverseView[1], inverseView[2]];
-  return [
-    cameraPosition[0] + right[0] * eyeOffset,
-    cameraPosition[1] + right[1] * eyeOffset,
-    cameraPosition[2] + right[2] * eyeOffset
-  ];
-}
-
-function eyeViewport(eye: StereoEye, viewport: StereoViewport, layout: StereoLayout): StereoViewport {
-  if (layout === "side-by-side") {
-    const halfWidth = Math.floor(viewport.width / 2);
-    return eye === "left"
-      ? { x: viewport.x, y: viewport.y, width: halfWidth, height: viewport.height }
-      : { x: viewport.x + halfWidth, y: viewport.y, width: viewport.width - halfWidth, height: viewport.height };
-  }
-  const halfHeight = Math.floor(viewport.height / 2);
-  return eye === "left"
-    ? { x: viewport.x, y: viewport.y, width: viewport.width, height: halfHeight }
-    : { x: viewport.x, y: viewport.y + halfHeight, width: viewport.width, height: viewport.height - halfHeight };
-}
-
-function validateViewport(viewport: StereoViewport): void {
-  const values = [viewport.x, viewport.y, viewport.width, viewport.height];
-  if (values.some((value) => !Number.isFinite(value))) {
-    throw new RangeError("Stereo viewport values must be finite.");
-  }
-  if (viewport.width < 2 || viewport.height < 2) {
-    throw new RangeError("Stereo viewport dimensions must be at least 2x2.");
-  }
-}
-
-function translationMat4(x: number, y: number, z: number): Mat4 {
-  return [
-    1, 0, 0, 0,
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    x, y, z, 1
-  ];
-}

package/src/StereoEffects.ts

@@ -1,274 +0,0 @@
-import type { StereoLayout } from "./StereoCameraRig";
-
-export type StereoEffectMode = "side-by-side" | "anaglyph" | "parallax-barrier";
-
-export interface StereoEffectPlanOptions {
-  readonly mode: StereoEffectMode;
-  readonly width: number;
-  readonly height: number;
-  readonly eyeSeparation: number;
-  readonly convergenceDistance: number;
-  readonly parallaxStrength?: number;
-  readonly parallaxBarrierAxis?: "x" | "y";
-  readonly stripPitchPx?: number;
-  readonly layout?: StereoLayout;
-}
-
-export interface StereoEffectPlan {
-  readonly mode: StereoEffectMode;
-  readonly layout: StereoLayout;
-  readonly width: number;
-  readonly height: number;
-  readonly eyeCount: 2;
-  readonly eyeSeparation: number;
-  readonly convergenceDistance: number;
-  readonly parallaxStrength: number;
-  readonly parallaxSignal: number;
-  readonly composition: "dual-canvas" | "channel-composite" | "interleaved-mask";
-  readonly anaglyph?: AnaglyphCompositePlan;
-  readonly parallaxBarrier?: ParallaxBarrierInterleavePlan;
-}
-
-export interface AnaglyphCompositePlan {
-  readonly leftChannel: "red";
-  readonly rightChannels: readonly ["green", "blue"];
-  readonly leftCssFilter: string;
-  readonly rightCssFilter: string;
-  readonly blendMode: "screen";
-}
-
-export interface AnaglyphPixelCompositeOptions {
-  readonly width: number;
-  readonly height: number;
-  readonly leftPixels: Uint8Array | Uint8ClampedArray;
-  readonly rightPixels: Uint8Array | Uint8ClampedArray;
-  readonly flipY?: boolean;
-}
-
-export interface AnaglyphPixelComposite {
-  readonly width: number;
-  readonly height: number;
-  readonly pixels: Uint8ClampedArray;
-  readonly composition: "renderer-owned-anaglyph-pixels";
-  readonly leftChannel: "red";
-  readonly rightChannels: readonly ["green", "blue"];
-}
-
-export interface ParallaxBarrierInterleavePlan {
-  readonly axis: "x" | "y";
-  readonly stripPitchPx: number;
-  readonly dutyCycle: number;
-  readonly leftMaskImage: string;
-  readonly rightMaskImage: string;
-  readonly overlayBackground: string;
-  readonly rightOpacity: number;
-}
-
-export interface ParallaxBarrierPixelCompositeOptions {
-  readonly width: number;
-  readonly height: number;
-  readonly leftPixels: Uint8Array | Uint8ClampedArray;
-  readonly rightPixels: Uint8Array | Uint8ClampedArray;
-  readonly axis?: "x" | "y";
-  readonly stripPitchPx?: number;
-  readonly dutyCycle?: number;
-  readonly flipY?: boolean;
-}
-
-export interface ParallaxBarrierPixelComposite {
-  readonly width: number;
-  readonly height: number;
-  readonly pixels: Uint8ClampedArray;
-  readonly axis: "x" | "y";
-  readonly stripPitchPx: number;
-  readonly dutyCycle: number;
-  readonly leftPixelCount: number;
-  readonly rightPixelCount: number;
-  readonly composition: "renderer-owned-interleaved-pixels";
-}
-
-export function createStereoEffectPlan(options: StereoEffectPlanOptions): StereoEffectPlan {
-  validatePositiveFinite(options.width, "Stereo effect width");
-  validatePositiveFinite(options.height, "Stereo effect height");
-  validatePositiveFinite(options.eyeSeparation, "Stereo effect eyeSeparation");
-  validatePositiveFinite(options.convergenceDistance, "Stereo effect convergenceDistance");
-  const parallaxStrength = options.parallaxStrength ?? 1;
-  validatePositiveFinite(parallaxStrength, "Stereo effect parallaxStrength");
-  const layout = options.layout ?? "side-by-side";
-  const base = {
-    mode: options.mode,
-    layout,
-    width: options.width,
-    height: options.height,
-    eyeCount: 2 as const,
-    eyeSeparation: options.eyeSeparation,
-    convergenceDistance: options.convergenceDistance,
-    parallaxStrength,
-    parallaxSignal: options.eyeSeparation * parallaxStrength / options.convergenceDistance
-  };
-  if (options.mode === "anaglyph") {
-    return {
-      ...base,
-      composition: "channel-composite",
-      anaglyph: createAnaglyphCompositePlan()
-    };
-  }
-  if (options.mode === "parallax-barrier") {
-    return {
-      ...base,
-      composition: "interleaved-mask",
-      parallaxBarrier: createParallaxBarrierInterleavePlan({
-        axis: options.parallaxBarrierAxis,
-        stripPitchPx: options.stripPitchPx
-      })
-    };
-  }
-  return {
-    ...base,
-    composition: "dual-canvas"
-  };
-}
-
-export function createAnaglyphCompositePlan(): AnaglyphCompositePlan {
-  return {
-    leftChannel: "red",
-    rightChannels: ["green", "blue"],
-    leftCssFilter: "sepia(1) saturate(5) hue-rotate(-50deg)",
-    rightCssFilter: "sepia(1) saturate(4) hue-rotate(135deg)",
-    blendMode: "screen"
-  };
-}
-
-export function createAnaglyphPixelComposite(options: AnaglyphPixelCompositeOptions): AnaglyphPixelComposite {
-  validatePositiveInteger(options.width, "Anaglyph composite width");
-  validatePositiveInteger(options.height, "Anaglyph composite height");
-  const expectedLength = options.width * options.height * 4;
-  if (options.leftPixels.length !== expectedLength || options.rightPixels.length !== expectedLength) {
-    throw new RangeError("Anaglyph composite requires leftPixels and rightPixels to be width * height * 4 bytes.");
-  }
-
-  const output = new Uint8ClampedArray(expectedLength);
-  for (let y = 0; y < options.height; y += 1) {
-    const sourceY = options.flipY ? options.height - y - 1 : y;
-    for (let x = 0; x < options.width; x += 1) {
-      const sourceOffset = (sourceY * options.width + x) * 4;
-      const outputOffset = (y * options.width + x) * 4;
-      output[outputOffset] = options.leftPixels[sourceOffset] ?? 0;
-      output[outputOffset + 1] = options.rightPixels[sourceOffset + 1] ?? 0;
-      output[outputOffset + 2] = options.rightPixels[sourceOffset + 2] ?? 0;
-      output[outputOffset + 3] = Math.max(options.leftPixels[sourceOffset + 3] ?? 255, options.rightPixels[sourceOffset + 3] ?? 255);
-    }
-  }
-
-  return {
-    width: options.width,
-    height: options.height,
-    pixels: output,
-    composition: "renderer-owned-anaglyph-pixels",
-    leftChannel: "red",
-    rightChannels: ["green", "blue"]
-  };
-}
-
-export function createParallaxBarrierInterleavePlan(options: {
-  readonly axis?: "x" | "y";
-  readonly stripPitchPx?: number;
-  readonly dutyCycle?: number;
-  readonly rightOpacity?: number;
-} = {}): ParallaxBarrierInterleavePlan {
-  const axis = options.axis ?? "x";
-  validateAxis(axis);
-  const stripPitchPx = options.stripPitchPx ?? 12;
-  const dutyCycle = options.dutyCycle ?? 0.5;
-  const rightOpacity = options.rightOpacity ?? 0.82;
-  validatePositiveFinite(stripPitchPx, "Parallax barrier stripPitchPx");
-  if (!Number.isFinite(dutyCycle) || dutyCycle <= 0 || dutyCycle >= 1) {
-    throw new RangeError("Parallax barrier dutyCycle must be finite and in (0, 1).");
-  }
-  if (!Number.isFinite(rightOpacity) || rightOpacity < 0 || rightOpacity > 1) {
-    throw new RangeError("Parallax barrier rightOpacity must be finite and in [0, 1].");
-  }
-  const leftStop = stripPitchPx * dutyCycle;
-  const gradientAxis = axis === "x" ? "90deg" : "0deg";
-  return {
-    axis,
-    stripPitchPx,
-    dutyCycle,
-    leftMaskImage: `repeating-linear-gradient(${gradientAxis}, black 0 ${formatPx(leftStop)}, transparent ${formatPx(leftStop)} ${formatPx(stripPitchPx)})`,
-    rightMaskImage: `repeating-linear-gradient(${gradientAxis}, transparent 0 ${formatPx(leftStop)}, black ${formatPx(leftStop)} ${formatPx(stripPitchPx)})`,
-    overlayBackground: `repeating-linear-gradient(${gradientAxis}, rgba(255,255,255,0.06) 0 1px, transparent 1px ${formatPx(stripPitchPx)})`,
-    rightOpacity
-  };
-}
-
-export function createParallaxBarrierPixelComposite(options: ParallaxBarrierPixelCompositeOptions): ParallaxBarrierPixelComposite {
-  validatePositiveInteger(options.width, "Parallax barrier composite width");
-  validatePositiveInteger(options.height, "Parallax barrier composite height");
-  const stripPitchPx = options.stripPitchPx ?? 12;
-  const dutyCycle = options.dutyCycle ?? 0.5;
-  const axis = options.axis ?? "x";
-  validateAxis(axis);
-  validatePositiveFinite(stripPitchPx, "Parallax barrier stripPitchPx");
-  if (!Number.isFinite(dutyCycle) || dutyCycle <= 0 || dutyCycle >= 1) {
-    throw new RangeError("Parallax barrier dutyCycle must be finite and in (0, 1).");
-  }
-  const expectedLength = options.width * options.height * 4;
-  if (options.leftPixels.length !== expectedLength || options.rightPixels.length !== expectedLength) {
-    throw new RangeError("Parallax barrier composite requires leftPixels and rightPixels to be width * height * 4 bytes.");
-  }
-
-  const output = new Uint8ClampedArray(expectedLength);
-  let leftPixelCount = 0;
-  let rightPixelCount = 0;
-  const leftStripWidth = stripPitchPx * dutyCycle;
-  for (let y = 0; y < options.height; y += 1) {
-    const sourceY = options.flipY ? options.height - y - 1 : y;
-    for (let x = 0; x < options.width; x += 1) {
-      const coordinate = axis === "x" ? x : y;
-      const useLeft = (coordinate % stripPitchPx) < leftStripWidth;
-      const source = useLeft ? options.leftPixels : options.rightPixels;
-      const sourceOffset = (sourceY * options.width + x) * 4;
-      const outputOffset = (y * options.width + x) * 4;
-      output[outputOffset] = source[sourceOffset] ?? 0;
-      output[outputOffset + 1] = source[sourceOffset + 1] ?? 0;
-      output[outputOffset + 2] = source[sourceOffset + 2] ?? 0;
-      output[outputOffset + 3] = source[sourceOffset + 3] ?? 255;
-      if (useLeft) leftPixelCount += 1;
-      else rightPixelCount += 1;
-    }
-  }
-
-  return {
-    width: options.width,
-    height: options.height,
-    pixels: output,
-    axis,
-    stripPitchPx,
-    dutyCycle,
-    leftPixelCount,
-    rightPixelCount,
-    composition: "renderer-owned-interleaved-pixels"
-  };
-}
-
-function validateAxis(value: unknown): asserts value is "x" | "y" {
-  if (value !== "x" && value !== "y") {
-    throw new RangeError("Parallax barrier axis must be x or y.");
-  }
-}
-
-function validatePositiveFinite(value: number, label: string): void {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new RangeError(`${label} must be finite and positive.`);
-  }
-}
-
-function validatePositiveInteger(value: number, label: string): void {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new RangeError(`${label} must be a positive integer.`);
-  }
-}
-
-function formatPx(value: number): string {
-  return `${Number(value.toFixed(3))}px`;
-}