@aura3d/rendering 1.0.6

package/src/SpaceEnvironmentFixtures.ts

@@ -0,0 +1,200 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,274 @@
+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`;
+}