@aura3d/rendering 1.0.6

package/src/production-runtime/framegraph/FrameGraph.ts

@@ -0,0 +1,18 @@
+import type { RenderPass } from './RenderPass';
+
+export class FrameGraph {
+  private readonly passes: RenderPass[] = [];
+
+  addPass(pass: RenderPass): this {
+    this.passes.push(pass);
+    return this;
+  }
+
+  getPasses(): readonly RenderPass[] {
+    return this.passes;
+  }
+
+  compile(): readonly RenderPass[] {
+    return [...this.passes].sort((a, b) => a.kind.localeCompare(b.kind));
+  }
+}

package/src/production-runtime/framegraph/RenderPass.ts

@@ -0,0 +1,15 @@
+export type RenderPassKind = 'depth' | 'shadow' | 'opaque' | 'transparent' | 'skybox' | 'postprocess';
+
+export interface RenderPassExecutionContext {
+  readonly frameIndex: number;
+  readonly width: number;
+  readonly height: number;
+}
+
+export interface RenderPass {
+  readonly id: string;
+  readonly kind: RenderPassKind;
+  readonly reads: readonly string[];
+  readonly writes: readonly string[];
+  execute?(context: RenderPassExecutionContext): void;
+}

package/src/production-runtime/geometry/ProjectedDecalGeometry.ts

@@ -0,0 +1,439 @@
+import { Geometry } from "../../Geometry";
+import { IndexBuffer } from "../../IndexBuffer";
+import { VertexBuffer } from "../../VertexBuffer";
+import { VertexFormat } from "../../VertexFormat";
+
+export interface ProjectedDecalTriangleMesh {
+  readonly positions: readonly (readonly [number, number, number])[];
+  readonly normals?: readonly (readonly [number, number, number])[];
+  readonly indices?: readonly number[];
+}
+
+export interface ProjectedDecalBox {
+  readonly center: readonly [number, number, number];
+  readonly size: readonly [number, number, number];
+  readonly basis?: ProjectedDecalBasis;
+  readonly normalOffset?: number;
+  readonly shape?: ProjectedDecalShape;
+  readonly ellipseSegments?: number;
+}
+
+export interface ProjectedDecalBasis {
+  readonly right: readonly [number, number, number];
+  readonly up: readonly [number, number, number];
+  readonly normal: readonly [number, number, number];
+}
+
+export interface ProjectedDecalRay {
+  readonly origin: readonly [number, number, number];
+  readonly direction: readonly [number, number, number];
+}
+
+export interface ProjectedDecalGeometryResult {
+  readonly geometry: Geometry;
+  readonly sourceTriangleCount: number;
+  readonly clippedTriangleCount: number;
+  readonly vertexCount: number;
+}
+
+export interface ProjectedDecalRaycastOptions {
+  readonly size: readonly [number, number, number];
+  readonly normalOffset?: number;
+  readonly maxDistance?: number;
+  readonly includeBackfaces?: boolean;
+  readonly upHint?: readonly [number, number, number];
+  readonly shape?: ProjectedDecalShape;
+  readonly ellipseSegments?: number;
+}
+
+export interface ProjectedDecalRaycastHit {
+  readonly position: readonly [number, number, number];
+  readonly normal: readonly [number, number, number];
+  readonly distance: number;
+  readonly triangleIndex: number;
+}
+
+export interface ProjectedDecalRaycastResult extends ProjectedDecalGeometryResult {
+  readonly hit: ProjectedDecalRaycastHit;
+  readonly box: ProjectedDecalBox;
+}
+
+interface DecalVertex {
+  readonly position: [number, number, number];
+  readonly normal: [number, number, number];
+}
+
+interface ClipPlane {
+  readonly axis: 0 | 1 | 2;
+  readonly sign: -1 | 1;
+}
+
+export type ProjectedDecalShape = "box" | "ellipse";
+
+const CLIP_PLANES: readonly ClipPlane[] = [
+  { axis: 0, sign: 1 },
+  { axis: 0, sign: -1 },
+  { axis: 1, sign: 1 },
+  { axis: 1, sign: -1 },
+  { axis: 2, sign: 1 },
+  { axis: 2, sign: -1 }
+];
+
+export function createProjectedDecalGeometry(mesh: ProjectedDecalTriangleMesh, box: ProjectedDecalBox): ProjectedDecalGeometryResult {
+  validateBox(box);
+  const triangles = triangleIndices(mesh);
+  const vertices: DecalVertex[] = [];
+  const indices: number[] = [];
+  const half: [number, number, number] = [box.size[0] / 2, box.size[1] / 2, box.size[2] / 2];
+  const basis = normalizeBasis(box.basis);
+  const normalOffset = box.normalOffset ?? 0.0025;
+  const shape = box.shape ?? "box";
+  const ellipseSegments = validateEllipseSegments(box.ellipseSegments ?? 32);
+  let clippedTriangleCount = 0;
+
+  for (let triangle = 0; triangle < triangles.length; triangle += 3) {
+    const polygon = [0, 1, 2].map((offset) => {
+      const index = triangles[triangle + offset]!;
+      const position = mesh.positions[index];
+      if (!position) {
+        throw new Error(`Projected decal triangle references missing vertex ${index}.`);
+      }
+      return {
+        position: [position[0], position[1], position[2]] as [number, number, number],
+        normal: normalizeVec3(mesh.normals?.[index] ?? [0, 0, 1])
+      };
+    });
+    const clipped = shape === "ellipse"
+      ? clipPolygonToEllipse(clipPolygonToBox(polygon, box.center, half, basis), box.center, half, basis, ellipseSegments)
+      : clipPolygonToBox(polygon, box.center, half, basis);
+    if (clipped.length < 3) continue;
+    const start = vertices.length;
+    for (const vertex of clipped) {
+      vertices.push({
+        position: [
+          vertex.position[0] + vertex.normal[0] * normalOffset,
+          vertex.position[1] + vertex.normal[1] * normalOffset,
+          vertex.position[2] + vertex.normal[2] * normalOffset
+        ],
+        normal: vertex.normal
+      });
+    }
+    for (let i = 1; i < clipped.length - 1; i += 1) {
+      indices.push(start, start + i, start + i + 1);
+      clippedTriangleCount += 1;
+    }
+  }
+
+  if (vertices.length === 0 || indices.length === 0) {
+    throw new Error("Projected decal did not intersect the source mesh.");
+  }
+
+  const vertexBuffer = new VertexBuffer(VertexFormat.P3N3T2, vertices.length);
+  vertices.forEach((vertex, index) => {
+    const local = toBoxLocal(vertex.position, box.center, half, basis);
+    vertexBuffer.setAttribute(index, "position", vertex.position);
+    vertexBuffer.setAttribute(index, "normal", vertex.normal);
+    vertexBuffer.setAttribute(index, "uv", [
+      Math.max(0, Math.min(1, local[0] * 0.5 + 0.5)),
+      Math.max(0, Math.min(1, 1 - (local[1] * 0.5 + 0.5)))
+    ]);
+  });
+
+  return {
+    geometry: new Geometry(vertexBuffer, new IndexBuffer(indices, vertices.length)),
+    sourceTriangleCount: triangles.length / 3,
+    clippedTriangleCount,
+    vertexCount: vertices.length
+  };
+}
+
+export function createRaycastProjectedDecalGeometry(
+  mesh: ProjectedDecalTriangleMesh,
+  ray: ProjectedDecalRay,
+  options: ProjectedDecalRaycastOptions
+): ProjectedDecalRaycastResult {
+  validateRay(ray);
+  validateBox({ center: ray.origin, size: options.size });
+  const hit = raycastProjectedDecalMesh(mesh, ray, options);
+  if (!hit) {
+    throw new Error("Projected decal ray did not hit the source mesh.");
+  }
+  const basis = createProjectorBasis(hit.normal, options.upHint ?? [0, 1, 0]);
+  const box: ProjectedDecalBox = {
+    center: hit.position,
+    size: options.size,
+    basis,
+    ...(options.normalOffset === undefined ? {} : { normalOffset: options.normalOffset }),
+    ...(options.shape === undefined ? {} : { shape: options.shape }),
+    ...(options.ellipseSegments === undefined ? {} : { ellipseSegments: options.ellipseSegments })
+  };
+  return {
+    ...createProjectedDecalGeometry(mesh, box),
+    hit,
+    box
+  };
+}
+
+export function raycastProjectedDecalMesh(
+  mesh: ProjectedDecalTriangleMesh,
+  ray: ProjectedDecalRay,
+  options: Pick<ProjectedDecalRaycastOptions, "maxDistance" | "includeBackfaces"> = {}
+): ProjectedDecalRaycastHit | undefined {
+  validateRay(ray);
+  const triangles = triangleIndices(mesh);
+  const direction = normalizeVec3(ray.direction);
+  const maxDistance = options.maxDistance ?? Number.POSITIVE_INFINITY;
+  if ((maxDistance !== Number.POSITIVE_INFINITY && !Number.isFinite(maxDistance)) || maxDistance <= 0) {
+    throw new Error("Projected decal ray maxDistance must be finite positive or omitted.");
+  }
+  let closest: ProjectedDecalRaycastHit | undefined;
+  for (let offset = 0; offset < triangles.length; offset += 3) {
+    const ia = triangles[offset]!;
+    const ib = triangles[offset + 1]!;
+    const ic = triangles[offset + 2]!;
+    const a = mesh.positions[ia];
+    const b = mesh.positions[ib];
+    const c = mesh.positions[ic];
+    if (!a || !b || !c) {
+      throw new Error("Projected decal raycast triangle references a missing vertex.");
+    }
+    const hit = intersectTriangle(ray.origin, direction, a, b, c, options.includeBackfaces === true);
+    if (!hit || hit.distance > maxDistance || (closest && hit.distance >= closest.distance)) continue;
+    const geometricNormal = triangleNormal(a, b, c);
+    const na = mesh.normals?.[ia] ?? geometricNormal;
+    const nb = mesh.normals?.[ib] ?? geometricNormal;
+    const nc = mesh.normals?.[ic] ?? geometricNormal;
+    closest = {
+      position: hit.position,
+      normal: normalizeVec3([
+        na[0] * hit.barycentric[0] + nb[0] * hit.barycentric[1] + nc[0] * hit.barycentric[2],
+        na[1] * hit.barycentric[0] + nb[1] * hit.barycentric[1] + nc[1] * hit.barycentric[2],
+        na[2] * hit.barycentric[0] + nb[2] * hit.barycentric[1] + nc[2] * hit.barycentric[2]
+      ]),
+      distance: hit.distance,
+      triangleIndex: offset / 3
+    };
+  }
+  return closest;
+}
+
+function triangleIndices(mesh: ProjectedDecalTriangleMesh): readonly number[] {
+  if (mesh.indices) {
+    if (mesh.indices.length === 0 || mesh.indices.length % 3 !== 0) {
+      throw new Error("Projected decal source indices must contain triangles.");
+    }
+    return mesh.indices;
+  }
+  if (mesh.positions.length === 0 || mesh.positions.length % 3 !== 0) {
+    throw new Error("Projected decal source positions must contain unindexed triangles.");
+  }
+  return mesh.positions.map((_position, index) => index);
+}
+
+function clipPolygonToBox(polygon: readonly DecalVertex[], center: readonly [number, number, number], half: readonly [number, number, number], basis: ProjectedDecalBasis): readonly DecalVertex[] {
+  let clipped = [...polygon];
+  for (const plane of CLIP_PLANES) {
+    clipped = clipPolygonToPlane(clipped, center, half, basis, plane);
+    if (clipped.length === 0) break;
+  }
+  return clipped;
+}
+
+function clipPolygonToEllipse(polygon: readonly DecalVertex[], center: readonly [number, number, number], half: readonly [number, number, number], basis: ProjectedDecalBasis, segments: number): readonly DecalVertex[] {
+  let clipped = [...polygon];
+  const apothem = Math.cos(Math.PI / segments);
+  for (let segment = 0; segment < segments; segment += 1) {
+    const angle = ((segment + 0.5) / segments) * Math.PI * 2;
+    clipped = clipPolygonToLocalPlane(clipped, center, half, basis, Math.cos(angle), Math.sin(angle), apothem);
+    if (clipped.length === 0) break;
+  }
+  return clipped;
+}
+
+function clipPolygonToPlane(polygon: readonly DecalVertex[], center: readonly [number, number, number], half: readonly [number, number, number], basis: ProjectedDecalBasis, plane: ClipPlane): DecalVertex[] {
+  const output: DecalVertex[] = [];
+  for (let index = 0; index < polygon.length; index += 1) {
+    const current = polygon[index]!;
+    const previous = polygon[(index + polygon.length - 1) % polygon.length]!;
+    const currentDistance = signedPlaneDistance(current.position, center, half, basis, plane);
+    const previousDistance = signedPlaneDistance(previous.position, center, half, basis, plane);
+    const currentInside = currentDistance <= 0;
+    const previousInside = previousDistance <= 0;
+    if (currentInside !== previousInside) {
+      const denominator = previousDistance - currentDistance;
+      const t = denominator === 0 ? 0 : previousDistance / denominator;
+      output.push(interpolateVertex(previous, current, t));
+    }
+    if (currentInside) {
+      output.push(current);
+    }
+  }
+  return output;
+}
+
+function clipPolygonToLocalPlane(polygon: readonly DecalVertex[], center: readonly [number, number, number], half: readonly [number, number, number], basis: ProjectedDecalBasis, normalX: number, normalY: number, limit: number): DecalVertex[] {
+  const output: DecalVertex[] = [];
+  for (let index = 0; index < polygon.length; index += 1) {
+    const current = polygon[index]!;
+    const previous = polygon[(index + polygon.length - 1) % polygon.length]!;
+    const currentDistance = localPlaneDistance(current.position, center, half, basis, normalX, normalY, limit);
+    const previousDistance = localPlaneDistance(previous.position, center, half, basis, normalX, normalY, limit);
+    const currentInside = currentDistance <= 0;
+    const previousInside = previousDistance <= 0;
+    if (currentInside !== previousInside) {
+      const denominator = previousDistance - currentDistance;
+      const t = denominator === 0 ? 0 : previousDistance / denominator;
+      output.push(interpolateVertex(previous, current, t));
+    }
+    if (currentInside) {
+      output.push(current);
+    }
+  }
+  return output;
+}
+
+function signedPlaneDistance(position: readonly [number, number, number], center: readonly [number, number, number], half: readonly [number, number, number], basis: ProjectedDecalBasis, plane: ClipPlane): number {
+  const local = toBoxLocal(position, center, half, basis)[plane.axis];
+  return plane.sign === 1 ? local - 1 : -local - 1;
+}
+
+function localPlaneDistance(position: readonly [number, number, number], center: readonly [number, number, number], half: readonly [number, number, number], basis: ProjectedDecalBasis, normalX: number, normalY: number, limit: number): number {
+  const local = toBoxLocal(position, center, half, basis);
+  return local[0] * normalX + local[1] * normalY - limit;
+}
+
+function interpolateVertex(a: DecalVertex, b: DecalVertex, t: number): DecalVertex {
+  return {
+    position: [
+      a.position[0] + (b.position[0] - a.position[0]) * t,
+      a.position[1] + (b.position[1] - a.position[1]) * t,
+      a.position[2] + (b.position[2] - a.position[2]) * t
+    ],
+    normal: normalizeVec3([
+      a.normal[0] + (b.normal[0] - a.normal[0]) * t,
+      a.normal[1] + (b.normal[1] - a.normal[1]) * t,
+      a.normal[2] + (b.normal[2] - a.normal[2]) * t
+    ])
+  };
+}
+
+function toBoxLocal(position: readonly [number, number, number], center: readonly [number, number, number], half: readonly [number, number, number], basis: ProjectedDecalBasis): [number, number, number] {
+  const delta: [number, number, number] = [
+    position[0] - center[0],
+    position[1] - center[1],
+    position[2] - center[2]
+  ];
+  return [
+    dot(delta, basis.right) / half[0],
+    dot(delta, basis.up) / half[1],
+    dot(delta, basis.normal) / half[2]
+  ];
+}
+
+function normalizeBasis(basis: ProjectedDecalBasis | undefined): ProjectedDecalBasis {
+  if (!basis) {
+    return { right: [1, 0, 0], up: [0, 1, 0], normal: [0, 0, 1] };
+  }
+  return createProjectorBasis(basis.normal, basis.up);
+}
+
+function createProjectorBasis(normalInput: readonly [number, number, number], upHintInput: readonly [number, number, number]): ProjectedDecalBasis {
+  const normal = normalizeVec3(normalInput);
+  let upHint = normalizeVec3(upHintInput);
+  if (Math.abs(dot(normal, upHint)) > 0.98) {
+    upHint = Math.abs(normal[1]) < 0.98 ? [0, 1, 0] : [1, 0, 0];
+  }
+  const right = normalizeVec3(cross(upHint, normal));
+  const up = normalizeVec3(cross(normal, right));
+  return { right, up, normal };
+}
+
+function intersectTriangle(
+  origin: readonly [number, number, number],
+  direction: readonly [number, number, number],
+  a: readonly [number, number, number],
+  b: readonly [number, number, number],
+  c: readonly [number, number, number],
+  includeBackfaces: boolean
+): { readonly position: [number, number, number]; readonly distance: number; readonly barycentric: [number, number, number] } | undefined {
+  const edge1 = sub(b, a);
+  const edge2 = sub(c, a);
+  const p = cross(direction, edge2);
+  const determinant = dot(edge1, p);
+  if (includeBackfaces ? Math.abs(determinant) < 1e-8 : determinant < 1e-8) return undefined;
+  const invDet = 1 / determinant;
+  const tvec = sub(origin, a);
+  const u = dot(tvec, p) * invDet;
+  if (u < 0 || u > 1) return undefined;
+  const q = cross(tvec, edge1);
+  const v = dot(direction, q) * invDet;
+  if (v < 0 || u + v > 1) return undefined;
+  const distance = dot(edge2, q) * invDet;
+  if (distance < 0) return undefined;
+  return {
+    position: [
+      origin[0] + direction[0] * distance,
+      origin[1] + direction[1] * distance,
+      origin[2] + direction[2] * distance
+    ],
+    distance,
+    barycentric: [1 - u - v, u, v]
+  };
+}
+
+function triangleNormal(a: readonly [number, number, number], b: readonly [number, number, number], c: readonly [number, number, number]): [number, number, number] {
+  return normalizeVec3(cross(sub(b, a), sub(c, a)));
+}
+
+function sub(a: readonly [number, number, number], b: readonly [number, number, number]): [number, number, number] {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+
+function dot(a: readonly [number, number, number], b: readonly [number, number, number]): number {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+function cross(a: readonly [number, number, number], b: readonly [number, number, number]): [number, number, number] {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+
+function normalizeVec3(value: readonly [number, number, number]): [number, number, number] {
+  const length = Math.hypot(value[0], value[1], value[2]);
+  if (!Number.isFinite(length) || length <= 1e-8) return [0, 0, 1];
+  return [value[0] / length, value[1] / length, value[2] / length];
+}
+
+function validateRay(ray: ProjectedDecalRay): void {
+  if (ray.origin.length !== 3 || ray.direction.length !== 3 || [...ray.origin, ...ray.direction].some((component) => !Number.isFinite(component))) {
+    throw new Error("Projected decal ray origin and direction must be finite vec3 values.");
+  }
+  if (Math.hypot(ray.direction[0], ray.direction[1], ray.direction[2]) <= 1e-8) {
+    throw new Error("Projected decal ray direction must be non-zero.");
+  }
+}
+
+function validateBox(box: ProjectedDecalBox): void {
+  for (const [label, value] of [["center", box.center], ["size", box.size]] as const) {
+    if (value.length !== 3 || value.some((component) => !Number.isFinite(component))) {
+      throw new Error(`Projected decal ${label} must be a finite vec3.`);
+    }
+  }
+  if (box.size.some((component) => component <= 0)) {
+    throw new Error("Projected decal size components must be positive.");
+  }
+  if (box.shape !== undefined && box.shape !== "box" && box.shape !== "ellipse") {
+    throw new Error("Projected decal shape must be box or ellipse.");
+  }
+  if (box.ellipseSegments !== undefined) validateEllipseSegments(box.ellipseSegments);
+}
+
+function validateEllipseSegments(segments: number): number {
+  if (!Number.isInteger(segments) || segments < 8 || segments > 128) {
+    throw new Error("Projected decal ellipseSegments must be an integer from 8 to 128.");
+  }
+  return segments;
+}

package/src/production-runtime/index.ts

@@ -0,0 +1,127 @@
+export {
+  ProductionWebGL2Renderer,
+  analyzePixels,
+  summarizeProductionProductionProof,
+  summarizeProductionWebGL2Proof
+} from "./ProductionWebGL2Renderer";
+export type { ProductionWebGL2RendererOptions } from "./ProductionWebGL2Renderer";
+export {
+  createProductionEnvironmentLightingResources,
+  createProductionPbrHdrPipelineFromRadiance,
+  createProductionToneMappingPolicy,
+  parseProductionRadianceHDR
+} from "./PBRHDRPipeline";
+export {
+  createProductionEffectsRenderSource,
+  summarizeProductionEffectsProof
+} from "./ProductionEffectsPipeline";
+export {
+  ProductionWebGPURenderer,
+  createProductionWebGPUReport,
+  createProductionWebGPUReadinessReport
+} from "./ProductionWebGPURenderer";
+export {
+  createProductionOrbitControlPreset,
+  summarizeProductionAnimationWorkflow
+} from "./AnimationControlsPipeline";
+export type {
+  ProductionEnvironmentLightingResources,
+  ProductionPbrHdrPipeline,
+  ProductionPbrHdrPipelineOptions,
+  ProductionRadianceHDR,
+  ProductionToneMappingOperator,
+  ProductionToneMappingPolicy
+} from "./PBRHDRPipeline";
+export type {
+  ProductionEffectsOptions,
+  ProductionEffectsSummary
+} from "./ProductionEffectsPipeline";
+export type {
+  ProductionWebGPUAdapterLike,
+  ProductionWebGPULike,
+  ProductionWebGPUReport,
+  ProductionWebGPUStatus,
+  ProductionWebGPUReadinessItem,
+  ProductionWebGPUReadinessReport,
+  ProductionWebGPURendererOptions
+} from "./ProductionWebGPURenderer";
+export type {
+  ProductionAnimationMetadataInput,
+  ProductionAnimationWorkflowSummary,
+  ProductionOrbitControlPreset
+} from "./AnimationControlsPipeline";
+export {
+  PRODUCTION_WEBGL2_REQUIRED_FEATURES,
+  RUNTIME_PARITY_WEBGPU_REQUIRED_FEATURES
+} from "./ProductionRendererTypes";
+export type {
+  ProductionImportedAssetRenderMetadata,
+  ProductionPixelMetrics,
+  ProductionProductionRenderer,
+  ProductionRenderProof,
+  ProductionRendererBackend,
+  ProductionRendererFeature,
+  ProductionRendererFeatureState,
+  ProductionRendererInput,
+  RuntimeParityFrameRenderResult
+} from "./ProductionRendererTypes";
+export * from "./ProductionRuntimeRenderer";
+export * from "./backends/RendererBackend";
+export * from "./backends/WebGL2RendererBackend";
+export * from "./backends/WebGPURendererBackend";
+export * from "./framegraph/FrameGraph";
+export * from "./framegraph/RenderPass";
+export * from "./resources/GPUBuffer";
+export * from "./resources/GPUTexture";
+export * from "./resources/RenderTarget";
+export * from "./resources/ResourceCache";
+export * from "./scene/RenderableScene";
+export * from "./scene/RenderableMesh";
+export * from "./scene/RenderablePrimitive";
+export * from "./scene/Camera";
+export * from "./scene/Lights";
+export * from "./materials/PBRMaterial";
+export * from "./materials/PBRShaderFeatures";
+export * from "./materials/MaterialCompiler";
+export * from "./materials/MaterialTextureBindings";
+export * from "./materials/GLTFMaterialAdapter";
+export * from "./materials/GLTFPBRMaterialAdapter";
+export * from "./shaders/ShaderProgramLibrary";
+export * from "./environment/HDRLoader";
+export * from "./environment/PMREMGenerator";
+export * from "./environment/EnvironmentMap";
+export * from "./geometry/ProjectedDecalGeometry";
+export * from "./passes/DepthPrepass";
+export * from "./passes/ShadowPass";
+export * from "./passes/ContactShadowPass";
+export * from "./passes/OpaquePass";
+export * from "./passes/TransparentPass";
+export * from "./passes/SkyboxPass";
+export * from "./passes/ToneMappingPass";
+export * from "./postprocess/ProductionEffectComposer";
+export * from "./postprocess/ProductionPostProcessTypes";
+export * from "./postprocess/BloomPass";
+export * from "./postprocess/SSAOPass";
+export * from "./postprocess/DOFPass";
+export * from "./postprocess/FXAAPass";
+export * from "./postprocess/ColorGradingPass";
+export * from "./animation/SkinningRenderer";
+export * from "./animation/MorphTargetRenderer";
+export * from "./diagnostics/FrameCapture";
+export * from "./diagnostics/RendererStats";
+export * from "./diagnostics/GPUCapabilities";
+export * from "./lights/LightManager";
+export * from "./lights/ShadowMapRenderer";
+export * from "./color/ColorManagement";
+export * from "./color/ToneMapping";
+export * from "./backends/webgl2/WebGL2Shader";
+export * from "./backends/webgl2/WebGL2Buffer";
+export * from "./backends/webgl2/WebGL2Texture";
+export * from "./backends/webgl2/WebGL2RenderTarget";
+export * from "./backends/webgl2/WebGL2StateCache";
+export * from "./backends/webgl2/WebGL2Capabilities";
+export * from "./backends/webgpu/WebGPUShader";
+export * from "./backends/webgpu/WebGPUBuffer";
+export * from "./backends/webgpu/WebGPUTexture";
+export * from "./backends/webgpu/WebGPURenderTarget";
+export * from "./backends/webgpu/WebGPUCapabilities";

package/src/production-runtime/lights/LightManager.ts

@@ -0,0 +1,7 @@
+import type { Light } from '../scene/Lights';
+export class LightManager {
+  private readonly lights = new Map<string, Light>();
+  add(light: Light): void { this.lights.set(light.id, light); }
+  list(): readonly Light[] { return [...this.lights.values()]; }
+  get shadowCastingCount(): number { return this.list().filter((light) => light.castsShadow).length; }
+}

package/src/production-runtime/lights/ShadowMapRenderer.ts

@@ -0,0 +1,5 @@
+import type { Light } from '../scene/Lights';
+export interface ShadowMapPlan { readonly lightId: string; readonly resolution: number; readonly bias: number; }
+export function createShadowMapPlans(lights: readonly Light[], resolution = 2048): readonly ShadowMapPlan[] {
+  return lights.filter((light) => light.castsShadow).map((light) => ({ lightId: light.id, resolution, bias: light.type === 'directional' ? 0.0008 : 0.002 }));
+}

package/src/production-runtime/materials/GLTFMaterialAdapter.ts

@@ -0,0 +1,6 @@
+import type { PBRMaterial } from './PBRMaterial';
+export interface GLTFMaterialLike { readonly name?: string; readonly alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND'; readonly doubleSided?: boolean; readonly extensions?: Record<string, unknown>; readonly pbrMetallicRoughness?: { readonly baseColorFactor?: readonly number[]; readonly metallicFactor?: number; readonly roughnessFactor?: number }; }
+export function adaptGLTFMaterial(material: GLTFMaterialLike, id = material.name ?? 'gltf-material'): PBRMaterial {
+  const factor = material.pbrMetallicRoughness?.baseColorFactor ?? [1, 1, 1, 1];
+  return { id, name: material.name ?? id, baseColorFactor: [Number(factor[0] ?? 1), Number(factor[1] ?? 1), Number(factor[2] ?? 1), Number(factor[3] ?? 1)], metallicFactor: material.pbrMetallicRoughness?.metallicFactor ?? 1, roughnessFactor: material.pbrMetallicRoughness?.roughnessFactor ?? 1, alphaMode: material.alphaMode ?? 'OPAQUE', doubleSided: material.doubleSided ?? false, textures: {}, extensions: Object.keys(material.extensions ?? {}) };
+}

package/src/production-runtime/materials/GLTFPBRMaterialAdapter.ts

@@ -0,0 +1,2 @@
+export { adaptGLTFMaterial as adaptGLTFPBRMaterial } from './GLTFMaterialAdapter';
+export type { GLTFMaterialLike } from './GLTFMaterialAdapter';

package/src/production-runtime/materials/MaterialCompiler.ts

@@ -0,0 +1,7 @@
+import type { PBRMaterial } from './PBRMaterial';
+import type { PBRShaderFeatures } from './PBRShaderFeatures';
+export interface CompiledMaterialProgram { readonly key: string; readonly defines: readonly string[]; readonly material: PBRMaterial; }
+export function compilePBRMaterial(material: PBRMaterial, features: Partial<PBRShaderFeatures> = {}): CompiledMaterialProgram {
+  const defines = Object.entries(features).filter(([, enabled]) => enabled).map(([name]) => 'USE_' + name.replace(/[A-Z]/g, (c) => '_' + c).toUpperCase());
+  return { key: [material.id, ...defines].join('|'), defines, material };
+}

package/src/production-runtime/materials/MaterialTextureBindings.ts

@@ -0,0 +1,5 @@
+import type { PBRMaterial } from './PBRMaterial';
+export interface MaterialTextureBinding { readonly slot: keyof PBRMaterial['textures']; readonly textureId: string; readonly colorSpace: 'srgb' | 'linear' | 'hdr'; }
+export function collectMaterialTextureBindings(material: PBRMaterial): readonly MaterialTextureBinding[] {
+  return Object.entries(material.textures).map(([slot, textureId]) => ({ slot: slot as keyof PBRMaterial['textures'], textureId: String(textureId), colorSpace: slot === 'baseColor' || slot === 'emissive' ? 'srgb' : 'linear' }));
+}

package/src/production-runtime/materials/PBRMaterial.ts

@@ -0,0 +1,2 @@
+export interface PBRMaterialTextureSlots { readonly baseColor?: string; readonly metallicRoughness?: string; readonly normal?: string; readonly occlusion?: string; readonly emissive?: string; readonly transmission?: string; readonly sheen?: string; readonly clearcoat?: string; readonly specular?: string; }
+export interface PBRMaterial { readonly id: string; readonly name: string; readonly baseColorFactor: readonly [number, number, number, number]; readonly metallicFactor: number; readonly roughnessFactor: number; readonly alphaMode: 'OPAQUE' | 'MASK' | 'BLEND'; readonly doubleSided: boolean; readonly textures: PBRMaterialTextureSlots; readonly extensions: readonly string[]; }

package/src/production-runtime/materials/PBRShaderFeatures.ts

@@ -0,0 +1,2 @@
+export interface PBRShaderFeatures { readonly normalMap: boolean; readonly occlusionMap: boolean; readonly emissiveMap: boolean; readonly clearcoat: boolean; readonly sheen: boolean; readonly specular: boolean; readonly transmission: boolean; readonly skinning: boolean; readonly morphTargets: boolean; }
+export const PRODUCTION_PBR_SHADER_FEATURES: PBRShaderFeatures = { normalMap: true, occlusionMap: true, emissiveMap: true, clearcoat: true, sheen: true, specular: true, transmission: true, skinning: true, morphTargets: true };