@aura3d/rendering 1.0.6

package/src/production-runtime/postprocess/ProductionPostProcessTypes.ts

@@ -0,0 +1,174 @@
+import type {
+  DepthTextureBinding,
+  PostProcessColorSpace,
+  ToneMappingOperator
+} from "../../PostProcessPass";
+
+export interface ProductionPostProcessInput {
+  readonly width: number;
+  readonly height: number;
+  readonly pixels: Uint8Array;
+  readonly depth?: DepthTextureBinding;
+  readonly history?: Uint8Array;
+  readonly velocity?: Float32Array;
+}
+
+export interface ProductionPostProcessOutput extends ProductionPostProcessInput {
+  readonly passName: string;
+  readonly changedPixels: number;
+  readonly metrics: Readonly<Record<string, number | string | boolean>>;
+  readonly diagnostics: readonly string[];
+}
+
+export interface ProductionPostProcessPass {
+  readonly name: string;
+  readonly enabled: boolean;
+  apply(input: ProductionPostProcessInput): ProductionPostProcessOutput;
+}
+
+export interface ProductionToneMapOptions {
+  readonly exposure?: number;
+  readonly whitePoint?: number;
+  readonly gamma?: number;
+  readonly operator?: ToneMappingOperator;
+  readonly inputColorSpace?: PostProcessColorSpace;
+  readonly outputColorSpace?: PostProcessColorSpace;
+}
+
+export function createProductionPostProcessInput(
+  pixels: Uint8Array,
+  width: number,
+  height: number,
+  options: Omit<ProductionPostProcessInput, "pixels" | "width" | "height"> = {}
+): ProductionPostProcessInput {
+  validateProductionPixels(pixels, width, height);
+  return {
+    width,
+    height,
+    pixels: new Uint8Array(pixels),
+    ...options
+  };
+}
+
+export function createProductionDemoPostProcessInput(width = 64, height = 48): ProductionPostProcessInput {
+  const pixels = new Uint8Array(width * height * 4);
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const index = (y * width + x) * 4;
+      let red = 18 + Math.round(x * 1.9);
+      let green = 22 + Math.round(y * 2.2);
+      let blue = 36 + Math.round((x + y) * 0.72);
+      if (x >= width * 0.16 && x <= width * 0.36 && y >= height * 0.18 && y <= height * 0.52) {
+        red = 248;
+        green = 196;
+        blue = 72;
+      }
+      if (x >= width * 0.58 && x <= width * 0.82 && y >= height * 0.24 && y <= height * 0.62) {
+        red = 44;
+        green = 188;
+        blue = 248;
+      }
+      if ((Math.abs(x - width * 0.48) < 1.2 || Math.abs(y - height * 0.72) < 1.2) && x > width * 0.12 && x < width * 0.88) {
+        red = 246;
+        green = 246;
+        blue = 240;
+      }
+      pixels[index] = red;
+      pixels[index + 1] = green;
+      pixels[index + 2] = blue;
+      pixels[index + 3] = 255;
+    }
+  }
+  return {
+    width,
+    height,
+    pixels,
+    depth: createProductionDepthProxy(width, height),
+    history: createProductionHistoryProxy(pixels, width, height),
+    velocity: createProductionVelocityProxy(width, height)
+  };
+}
+
+export function createProductionPostProcessOutput(
+  input: ProductionPostProcessInput,
+  passName: string,
+  pixels: Uint8Array,
+  metrics: Readonly<Record<string, number | string | boolean>>,
+  diagnostics: readonly string[]
+): ProductionPostProcessOutput {
+  validateProductionPixels(pixels, input.width, input.height);
+  return {
+    ...input,
+    pixels,
+    passName,
+    changedPixels: countChangedRgb(input.pixels, pixels),
+    metrics,
+    diagnostics
+  };
+}
+
+export function createProductionDepthProxy(width: number, height: number): DepthTextureBinding {
+  const data = new Float32Array(width * height);
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const center = Math.hypot((x / Math.max(1, width - 1)) * 2 - 1, (y / Math.max(1, height - 1)) * 2 - 1);
+      let depth = 0.76 - Math.max(0, 0.34 - center * 0.16);
+      if (y > height * 0.68) depth = 0.56;
+      if (x >= width * 0.16 && x <= width * 0.36 && y >= height * 0.18 && y <= height * 0.52) depth = 0.28;
+      if (x >= width * 0.58 && x <= width * 0.82 && y >= height * 0.24 && y <= height * 0.62) depth = 0.42;
+      data[y * width + x] = depth;
+    }
+  }
+  return { label: "production-postprocess-depth-proxy", width, height, format: "depth24", data };
+}
+
+export function createProductionHistoryProxy(pixels: Uint8Array, width: number, height: number): Uint8Array {
+  validateProductionPixels(pixels, width, height);
+  const history = new Uint8Array(pixels.length);
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const sourceX = Math.max(0, x - 2);
+      const source = (y * width + sourceX) * 4;
+      const target = (y * width + x) * 4;
+      history[target] = Math.max(0, (pixels[source] ?? 0) - 14);
+      history[target + 1] = Math.max(0, (pixels[source + 1] ?? 0) - 10);
+      history[target + 2] = Math.max(0, (pixels[source + 2] ?? 0) - 8);
+      history[target + 3] = pixels[source + 3] ?? 255;
+    }
+  }
+  return history;
+}
+
+export function createProductionVelocityProxy(width: number, height: number): Float32Array {
+  const velocity = new Float32Array(width * height * 2);
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      if (x < width * 0.78 && y > height * 0.16 && y < height * 0.7) {
+        const index = (y * width + x) * 2;
+        velocity[index] = 1.5;
+        velocity[index + 1] = x > width * 0.48 ? -0.5 : 0.25;
+      }
+    }
+  }
+  return velocity;
+}
+
+export function countChangedRgb(a: Uint8Array, b: Uint8Array): number {
+  let changed = 0;
+  for (let index = 0; index < Math.min(a.length, b.length); index += 4) {
+    const delta = Math.abs((a[index] ?? 0) - (b[index] ?? 0))
+      + Math.abs((a[index + 1] ?? 0) - (b[index + 1] ?? 0))
+      + Math.abs((a[index + 2] ?? 0) - (b[index + 2] ?? 0));
+    if (delta > 0) changed += 1;
+  }
+  return changed;
+}
+
+export function validateProductionPixels(pixels: Uint8Array, width: number, height: number): void {
+  if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+    throw new Error("Production postprocess dimensions must be positive integers.");
+  }
+  if (pixels.byteLength !== width * height * 4) {
+    throw new Error("Production postprocess input must contain width * height * 4 RGBA bytes.");
+  }
+}

package/src/production-runtime/postprocess/SSAOPass.ts

@@ -0,0 +1,45 @@
+import {
+  ssaoPixels,
+  type SSAOOptions,
+  type SSAOResult
+} from "../../PostProcessPass";
+import {
+  createProductionDepthProxy,
+  createProductionPostProcessOutput,
+  type ProductionPostProcessInput,
+  type ProductionPostProcessOutput,
+  type ProductionPostProcessPass
+} from "./ProductionPostProcessTypes";
+
+export interface SSAOPassOptions extends SSAOOptions {
+  readonly enabled?: boolean;
+}
+
+export class SSAOPass implements ProductionPostProcessPass {
+  readonly name = "production-ssao";
+  readonly enabled: boolean;
+  private lastResult: SSAOResult | null = null;
+
+  constructor(public readonly options: SSAOPassOptions = {}) {
+    this.enabled = options.enabled ?? true;
+  }
+
+  apply(input: ProductionPostProcessInput): ProductionPostProcessOutput {
+    const result = ssaoPixels(input.pixels, input.width, input.height, {
+      depth: this.options.depth ?? input.depth ?? createProductionDepthProxy(input.width, input.height),
+      radius: this.options.radius ?? 2,
+      intensity: this.enabled ? this.options.intensity ?? 0.58 : 0,
+      bias: this.options.bias ?? 0.01
+    });
+    this.lastResult = result;
+    return createProductionPostProcessOutput(input, this.name, result.pixels, {
+      occludedPixels: result.occludedPixels,
+      averageOcclusion: result.averageOcclusion,
+      radius: result.radius
+    }, ["SSAOPass applies the renderer SSAO pixel kernel with supplied or generated depth evidence."]);
+  }
+
+  getLastResult(): SSAOResult | null {
+    return this.lastResult ? { ...this.lastResult, pixels: new Uint8Array(this.lastResult.pixels) } : null;
+  }
+}

package/src/production-runtime/resources/GPUBuffer.ts

@@ -0,0 +1,2 @@
+export interface GPUBufferDescriptorProduction { readonly label: string; readonly byteLength: number; readonly usage: readonly string[]; }
+export class GPUBuffer { constructor(readonly descriptor: GPUBufferDescriptorProduction) {} }

package/src/production-runtime/resources/GPUTexture.ts

@@ -0,0 +1,2 @@
+export interface GPUTextureDescriptorProduction { readonly label: string; readonly width: number; readonly height: number; readonly format: string; readonly mipLevels?: number; }
+export class GPUTexture { constructor(readonly descriptor: GPUTextureDescriptorProduction) {} }

package/src/production-runtime/resources/RenderTarget.ts

@@ -0,0 +1,3 @@
+import type { GPUTexture } from './GPUTexture';
+export interface RenderTargetDescriptor { readonly label: string; readonly color: GPUTexture; readonly depth?: GPUTexture; }
+export class RenderTarget { constructor(readonly descriptor: RenderTargetDescriptor) {} }

package/src/production-runtime/resources/ResourceCache.ts

@@ -0,0 +1,7 @@
+export class ResourceCache<T> {
+  private readonly resources = new Map<string, T>();
+  get(key: string): T | undefined { return this.resources.get(key); }
+  set(key: string, value: T): T { this.resources.set(key, value); return value; }
+  clear(): void { this.resources.clear(); }
+  get size(): number { return this.resources.size; }
+}

package/src/production-runtime/scene/Camera.ts

@@ -0,0 +1 @@
+export interface Camera { readonly projectionMatrix: readonly number[]; readonly viewMatrix: readonly number[]; readonly exposure?: number; readonly near?: number; readonly far?: number; }

package/src/production-runtime/scene/Lights.ts

@@ -0,0 +1,2 @@
+export type LightType = 'directional' | 'point' | 'spot' | 'environment';
+export interface Light { readonly id: string; readonly type: LightType; readonly intensity: number; readonly color: readonly [number, number, number]; readonly castsShadow?: boolean; }

package/src/production-runtime/scene/RenderableMesh.ts

@@ -0,0 +1,2 @@
+import type { RenderablePrimitive } from './RenderablePrimitive';
+export interface RenderableMesh { readonly id: string; readonly name: string; readonly primitives: readonly RenderablePrimitive[]; readonly worldMatrix?: readonly number[]; }

package/src/production-runtime/scene/RenderablePrimitive.ts

@@ -0,0 +1 @@
+export interface RenderablePrimitive { readonly id: string; readonly vertexCount: number; readonly indexCount: number; readonly materialId: string; readonly attributes: readonly string[]; }

package/src/production-runtime/scene/RenderableScene.ts

@@ -0,0 +1,4 @@
+import type { Camera } from './Camera';
+import type { Light } from './Lights';
+import type { RenderableMesh } from './RenderableMesh';
+export interface RenderableScene { readonly id: string; readonly meshes: readonly RenderableMesh[]; readonly lights: readonly Light[]; readonly camera: Camera; readonly environmentId?: string; }

package/src/production-runtime/shaders/ShaderProgramLibrary.ts

@@ -0,0 +1,7 @@
+export interface ShaderProgramSource { readonly vertex: string; readonly fragment: string; readonly defines?: readonly string[]; }
+export class ShaderProgramLibrary {
+  private readonly programs = new Map<string, ShaderProgramSource>();
+  register(key: string, source: ShaderProgramSource): void { this.programs.set(key, source); }
+  get(key: string): ShaderProgramSource | undefined { return this.programs.get(key); }
+  keys(): readonly string[] { return [...this.programs.keys()]; }
+}

package/src/production-runtime/shaders/chunks/brdf.glsl

@@ -0,0 +1,2 @@
+// @aura3d-shader:production-brdf
+float distributionGGX(float nDotH, float roughness) { float a = roughness * roughness; float a2 = a * a; float denom = nDotH * nDotH * (a2 - 1.0) + 1.0; return a2 / max(3.14159265 * denom * denom, 0.0001); }

package/src/production-runtime/shaders/chunks/ibl.glsl

@@ -0,0 +1,3 @@
+// @aura3d-shader:production-ibl
+vec3 sampleIBLDiffuse(vec3 normal) { return vec3(0.6, 0.65, 0.7) * (0.5 + 0.5 * normal.y); }
+vec3 sampleIBLSpecular(vec3 reflection, float roughness) { return mix(vec3(1.0), vec3(0.25), roughness) * max(reflection.y * 0.5 + 0.5, 0.0); }

package/src/production-runtime/shaders/chunks/pbr.frag.glsl

@@ -0,0 +1,47 @@
+#version 300 es
+// @aura3d-shader:production-pbr-frag
+precision highp float;
+in vec3 vNormal;
+out vec4 fragColor;
+const float PI = 3.14159265359;
+float saturate(float value) {
+  return clamp(value, 0.0, 1.0);
+}
+vec3 fresnelSchlick(vec3 f0, float vDotH) {
+  return f0 + (vec3(1.0) - f0) * pow(saturate(1.0 - vDotH), 5.0);
+}
+float distributionGGX(float nDotH, float roughness) {
+  float alpha = max(roughness, 0.045);
+  alpha *= alpha;
+  float alpha2 = alpha * alpha;
+  float denom = nDotH * nDotH * (alpha2 - 1.0) + 1.0;
+  return alpha2 / max(PI * denom * denom, 0.00001);
+}
+float geometrySmith(float nDotV, float nDotL, float roughness) {
+  float k = pow(roughness + 1.0, 2.0) / 8.0;
+  float gv = nDotV / max(nDotV * (1.0 - k) + k, 0.00001);
+  float gl = nDotL / max(nDotL * (1.0 - k) + k, 0.00001);
+  return gv * gl;
+}
+vec3 evaluatePBR(vec3 baseColor, float metallic, float roughness, vec3 normal) {
+  vec3 N = normalize(normal);
+  vec3 V = normalize(vec3(0.0, 0.18, 1.0));
+  vec3 L = normalize(vec3(0.34, 0.72, 0.6));
+  vec3 H = normalize(V + L);
+  float nDotL = saturate(dot(N, L));
+  float nDotV = max(saturate(dot(N, V)), 0.00001);
+  float nDotH = saturate(dot(N, H));
+  float vDotH = saturate(dot(V, H));
+  vec3 f0 = mix(vec3(0.04), baseColor, metallic);
+  vec3 F = fresnelSchlick(f0, vDotH);
+  float D = distributionGGX(nDotH, roughness);
+  float G = geometrySmith(nDotV, nDotL, roughness);
+  vec3 specular = D * G * F / max(4.0 * nDotV * nDotL, 0.00001);
+  vec3 diffuse = (vec3(1.0) - F) * (1.0 - metallic) * baseColor / PI;
+  vec3 ambient = baseColor * mix(vec3(0.04, 0.045, 0.055), vec3(0.18, 0.22, 0.3), saturate(N.y * 0.5 + 0.5));
+  return ambient + (diffuse + specular) * nDotL * 3.0;
+}
+void main() {
+  vec3 color = evaluatePBR(vec3(0.86, 0.88, 0.9), 0.0, 0.38, vNormal);
+  fragColor = vec4(pow(clamp(color, vec3(0.0), vec3(1.0)), vec3(1.0 / 2.2)), 1.0);
+}

package/src/production-runtime/shaders/chunks/pbr.vert.glsl

@@ -0,0 +1,8 @@
+#version 300 es
+// @aura3d-shader:production-pbr-vert
+precision highp float;
+layout(location=0) in vec3 position;
+layout(location=1) in vec3 normal;
+uniform mat4 uModelViewProjection;
+out vec3 vNormal;
+void main() { vNormal = normal; gl_Position = uModelViewProjection * vec4(position, 1.0); }

package/src/production-runtime/shaders/chunks/shadows.glsl

@@ -0,0 +1,2 @@
+// @aura3d-shader:production-shadows
+float applyShadowBias(float depth, float bias) { return depth - bias; }

package/src/production-runtime/shaders/wgsl/pbr.wgsl

@@ -0,0 +1,3 @@
+// @aura3d-shader:production-wgsl-pbr
+struct VertexOutput { @builtin(position) position: vec4<f32>, @location(0) normal: vec3<f32> };
+@fragment fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> { return vec4<f32>(abs(input.normal), 1.0); }

package/src/production-runtime/shaders/wgsl/postprocess.wgsl

@@ -0,0 +1,2 @@
+// @aura3d-shader:production-wgsl-postprocess
+@fragment fn fs_postprocess(@location(0) color: vec4<f32>) -> @location(0) vec4<f32> { return color; }

package/src/production-runtime/shaders/wgsl/skybox.wgsl

@@ -0,0 +1,2 @@
+// @aura3d-shader:production-wgsl-skybox
+@fragment fn fs_skybox() -> @location(0) vec4<f32> { return vec4<f32>(0.45, 0.55, 0.7, 1.0); }

package/src/shaders/depth.frag.glsl

@@ -0,0 +1,5 @@
+#version 300 es
+// @aura3d-shader:depth
+precision highp float;
+void main() {
+}

package/src/shaders/depth.vert.glsl

@@ -0,0 +1,8 @@
+#version 300 es
+// @aura3d-shader:depth
+precision highp float;
+layout(location = 0) in vec3 a_position;
+uniform mat4 u_modelViewProjection;
+void main() {
+  gl_Position = u_modelViewProjection * vec4(a_position, 1.0);
+}