@aura3d/rendering 1.4.0 → 1.4.2

package/src/threejs-compatibility/vfx/SpriteSystem.ts

@@ -1,14 +0,0 @@
-export interface ThreeCompatSprite {
-  readonly id: string;
-  readonly x: number;
-  readonly y: number;
-  readonly size: number;
-}
-
-export class SpriteSystemThreeCompat {
-  readonly sprites: ThreeCompatSprite[] = [];
-
-  add(sprite: ThreeCompatSprite): void {
-    this.sprites.push(sprite);
-  }
-}

package/src/threejs-compatibility/vfx/TrailRenderer.ts

@@ -1,8 +0,0 @@
-export class TrailThreeCompatRenderer {
-  readonly points: Array<readonly [number, number, number]> = [];
-
-  push(point: readonly [number, number, number]): void {
-    this.points.push(point);
-    if (this.points.length > 256) this.points.shift();
-  }
-}

package/src/threejs-compatibility/vfx/VFXDiagnostics.ts

@@ -1,23 +0,0 @@
-import type { GPUPointCloudThreeCompat } from "./GPUPointCloud";
-import type { LineThreeCompatRenderer } from "./LineRenderer";
-import type { ParticleSystemThreeCompat } from "./ParticleSystem";
-import type { SpriteSystemThreeCompat } from "./SpriteSystem";
-import type { TrailThreeCompatRenderer } from "./TrailRenderer";
-
-export function createThreeCompatVfxDiagnostics(input: {
-  readonly particles: ParticleSystemThreeCompat;
-  readonly pointCloud: GPUPointCloudThreeCompat;
-  readonly sprites: SpriteSystemThreeCompat;
-  readonly lines: LineThreeCompatRenderer;
-  readonly trails: TrailThreeCompatRenderer;
-}) {
-  return {
-    particleCount: input.particles.particles.length,
-    pointCount: input.pointCloud.pointCount,
-    pointCloudBytes: input.pointCloud.estimatedBytes,
-    spriteCount: input.sprites.sprites.length,
-    lineSegmentCount: input.lines.segments.length,
-    trailPointCount: input.trails.points.length,
-    warnings: input.pointCloud.pointCount < 10000 ? ["Point cloud below ThreeCompat showcase density."] : []
-  };
-}

package/src/threejs-compatibility/vfx/index.ts

@@ -1,9 +0,0 @@
-export { ParticleSystemThreeCompat } from "./ParticleSystem";
-export type { ThreeCompatParticle } from "./ParticleSystem";
-export { GPUPointCloudThreeCompat } from "./GPUPointCloud";
-export { SpriteSystemThreeCompat } from "./SpriteSystem";
-export type { ThreeCompatSprite } from "./SpriteSystem";
-export { LineThreeCompatRenderer } from "./LineRenderer";
-export type { ThreeCompatLineSegment } from "./LineRenderer";
-export { TrailThreeCompatRenderer } from "./TrailRenderer";
-export { createThreeCompatVfxDiagnostics } from "./VFXDiagnostics";

package/src/threejs-example-parity/index.ts

@@ -1,205 +0,0 @@
-import { ProductionRuntimeRenderer, resolveProductionRuntimeRendererBackend, type ProductionRuntimeRendererBackendPreference, type ProductionRuntimeRendererBackendSelection } from "../production-runtime/ProductionRuntimeRenderer";
-import type { ProductionRendererInput, RuntimeParityFrameRenderResult } from "../production-runtime/ProductionRendererTypes";
-import type { RenderDeviceDiagnostics } from "../RenderDevice";
-import type { RendererPostProcessOptions } from "../Renderer";
-
-export interface CurrentRoutesInteractiveRendererOptions {
-  readonly canvas: HTMLCanvasElement | OffscreenCanvas;
-  readonly width: number;
-  readonly height: number;
-  readonly backend?: ProductionRuntimeRendererBackendPreference;
-  readonly preserveDrawingBuffer?: boolean;
-  readonly errorCheckMode?: "strict" | "frame";
-  readonly clearColor?: readonly [number, number, number, number];
-}
-
-export interface CurrentRoutesRuntimeMetrics {
-  readonly frameCount: number;
-  readonly lastFrameMs: number;
-  readonly averageFrameMs: number;
-  readonly lastRenderMs: number;
-  readonly averageRenderMs: number;
-  readonly drawCalls: number;
-  readonly textures: number;
-  readonly buffers: number;
-  readonly shaders: number;
-  readonly backend: "webgl2" | "webgpu";
-  readonly stateCacheIssued?: number;
-  readonly stateCacheSkipped?: number;
-  readonly stateCacheProgramSwitches?: number;
-  readonly stateCacheTextureBinds?: number;
-  readonly stateCacheBufferBinds?: number;
-  readonly stateCacheVertexArrayBinds?: number;
-  readonly stateCacheSamplerBinds?: number;
-}
-
-export interface CurrentRoutesScreenshot {
-  readonly mimeType: "image/png";
-  readonly dataUrl: string;
-  readonly width: number;
-  readonly height: number;
-}
-
-export class CurrentRoutesInteractiveRenderer {
-  readonly backend: "webgl2" | "webgpu";
-  readonly backendSelection: ProductionRuntimeRendererBackendSelection;
-
-  private readonly metrics = createCurrentRoutesRuntimeMetrics();
-
-  private constructor(
-    private readonly renderer: ProductionRuntimeRenderer,
-    readonly canvas: HTMLCanvasElement | OffscreenCanvas
-  ) {
-    this.backend = renderer.backend;
-    this.backendSelection = renderer.backendSelection;
-  }
-
-  static async create(options: CurrentRoutesInteractiveRendererOptions): Promise<CurrentRoutesInteractiveRenderer> {
-    const selection = resolveProductionRuntimeRendererBackend(options);
-    const renderer = await ProductionRuntimeRenderer.create({
-      ...options,
-      backend: selection.requestedBackend
-    });
-    return new CurrentRoutesInteractiveRenderer(renderer, options.canvas);
-  }
-
-  async renderFrame(input: ProductionRendererInput): Promise<RuntimeParityFrameRenderResult> {
-    const started = now();
-    const result = await this.renderer.renderInteractiveFrameAsync(input);
-    this.metrics.record({
-      frameMs: now() - started,
-      renderMs: result.timing?.renderMs ?? 0,
-      diagnostics: result.diagnostics,
-      backend: result.backend
-    });
-    return result;
-  }
-
-  resize(width: number, height: number): void {
-    this.renderer.resize(width, height);
-  }
-
-  getDiagnostics(): RenderDeviceDiagnostics {
-    return this.renderer.getDiagnostics();
-  }
-
-  getMetrics(): CurrentRoutesRuntimeMetrics {
-    return this.metrics.snapshot(this.backend);
-  }
-
-  screenshot(): CurrentRoutesScreenshot {
-    return captureCurrentRoutesCanvasScreenshot(this.canvas);
-  }
-
-  dispose(): void {
-    this.renderer.dispose();
-  }
-}
-
-export function createCurrentRoutesInteractiveRenderer(options: CurrentRoutesInteractiveRendererOptions): Promise<CurrentRoutesInteractiveRenderer> {
-  return CurrentRoutesInteractiveRenderer.create(options);
-}
-
-export function createCurrentRoutesPostprocess(exposure: number): RendererPostProcessOptions {
-  return {
-    targetFormat: "rgba16f",
-    toneMapping: {
-      operator: "filmic",
-      exposure: clamp(exposure, 0.1, 4),
-      whitePoint: 1.25,
-      inputColorSpace: "linear",
-      outputColorSpace: "srgb"
-    },
-    colorGrade: {
-      contrast: 1.08,
-      saturation: 1.05,
-      vibrance: 0.1,
-      vignette: 0.12,
-      sharpening: 0.22
-    },
-    bloom: {
-      threshold: 0.92,
-      intensity: 0.08,
-      radius: 1
-    },
-    fxaa: {
-      edgeThreshold: 0.08,
-      subpixelBlend: 0.55
-    }
-  };
-}
-
-export function captureCurrentRoutesCanvasScreenshot(canvas: HTMLCanvasElement | OffscreenCanvas): CurrentRoutesScreenshot {
-  if (!("toDataURL" in canvas) || typeof canvas.toDataURL !== "function") {
-    throw new Error("CurrentRoutes screenshot capture requires an HTMLCanvasElement with preserveDrawingBuffer enabled.");
-  }
-  return {
-    mimeType: "image/png",
-    dataUrl: canvas.toDataURL("image/png"),
-    width: canvas.width,
-    height: canvas.height
-  };
-}
-
-interface CurrentRoutesMetricsRecorder {
-  record(sample: {
-    readonly frameMs: number;
-    readonly renderMs: number;
-    readonly diagnostics: RenderDeviceDiagnostics;
-    readonly backend: "webgl2" | "webgpu";
-  }): void;
-  snapshot(backend: "webgl2" | "webgpu"): CurrentRoutesRuntimeMetrics;
-}
-
-function createCurrentRoutesRuntimeMetrics(): CurrentRoutesMetricsRecorder {
-  let frameCount = 0;
-  let lastFrameMs = 0;
-  let averageFrameMs = 0;
-  let lastRenderMs = 0;
-  let averageRenderMs = 0;
-  let diagnostics: RenderDeviceDiagnostics = { drawCalls: 0, buffers: 0, shaders: 0, lastError: null, contextLost: false };
-
-  return {
-    record(sample) {
-      frameCount += 1;
-      lastFrameMs = sample.frameMs;
-      lastRenderMs = sample.renderMs;
-      averageFrameMs += (sample.frameMs - averageFrameMs) / frameCount;
-      averageRenderMs += (sample.renderMs - averageRenderMs) / frameCount;
-      diagnostics = sample.diagnostics;
-    },
-    snapshot(backend) {
-      return {
-        frameCount,
-        lastFrameMs: round(lastFrameMs),
-        averageFrameMs: round(averageFrameMs),
-        lastRenderMs: round(lastRenderMs),
-        averageRenderMs: round(averageRenderMs),
-        drawCalls: diagnostics.drawCalls,
-        textures: diagnostics.textures ?? 0,
-        buffers: diagnostics.buffers,
-        shaders: diagnostics.shaders,
-        backend,
-        ...(diagnostics.stateCacheIssued !== undefined ? { stateCacheIssued: diagnostics.stateCacheIssued } : {}),
-        ...(diagnostics.stateCacheSkipped !== undefined ? { stateCacheSkipped: diagnostics.stateCacheSkipped } : {}),
-        ...(diagnostics.stateCacheProgramSwitches !== undefined ? { stateCacheProgramSwitches: diagnostics.stateCacheProgramSwitches } : {}),
-        ...(diagnostics.stateCacheTextureBinds !== undefined ? { stateCacheTextureBinds: diagnostics.stateCacheTextureBinds } : {}),
-        ...(diagnostics.stateCacheBufferBinds !== undefined ? { stateCacheBufferBinds: diagnostics.stateCacheBufferBinds } : {}),
-        ...(diagnostics.stateCacheVertexArrayBinds !== undefined ? { stateCacheVertexArrayBinds: diagnostics.stateCacheVertexArrayBinds } : {}),
-        ...(diagnostics.stateCacheSamplerBinds !== undefined ? { stateCacheSamplerBinds: diagnostics.stateCacheSamplerBinds } : {})
-      };
-    }
-  };
-}
-
-function now(): number {
-  return typeof performance !== "undefined" ? performance.now() : Date.now();
-}
-
-function round(value: number): number {
-  return Math.round(value * 100) / 100;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.min(max, Math.max(min, value));
-}

package/src/webgpu/WebGPUBuffer.ts

@@ -1 +0,0 @@
-export type { WebGPUBufferDescriptorLike, WebGPUBufferLike } from "../WebGPUDevice";

package/src/webgpu/WebGPUCompute.ts

@@ -1,2 +0,0 @@
-export { WebGPUParticleBackend } from "../effects/GPUParticleBackend";
-export type { WebGPUParticleBackendOptions } from "../effects/GPUParticleBackend";

package/src/webgpu/WebGPUPipelineCache.ts

@@ -1,15 +0,0 @@
-export class WebGPUPipelineCache<T = unknown> {
-  private readonly cache = new Map<string, T>();
-
-  getOrCreate(key: string, create: () => T): T {
-    const existing = this.cache.get(key);
-    if (existing !== undefined) return existing;
-    const value = create();
-    this.cache.set(key, value);
-    return value;
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-}

package/src/webgpu/WebGPUPostProcess.ts

@@ -1,2 +0,0 @@
-export { runWebGPURenderToTextureProof } from "../WebGPURenderToTextureProof";
-export type { WebGPURenderToTextureProof, WebGPURenderToTextureProofOptions } from "../WebGPURenderToTextureProof";

package/src/webgpu/WebGPUTexture.ts

@@ -1,2 +0,0 @@
-export type { WebGPUSamplerDescriptorLike } from "../WebGPUDevice";
-export { Texture } from "../Texture";

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "useUnknownInCatchVariables": true,
-    "exactOptionalPropertyTypes": false,
-    "isolatedModules": true,
-    "declaration": true,
-    "skipLibCheck": true,
-    "noEmit": true,
-    "paths": {
-      "@aura3d/scene": ["../scene/src/index.ts"],
-      "@aura3d/math": ["../math/src/index.ts"],
-      "@aura3d/core": ["../core/src/index.ts"]
-    }
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["src/effects/**"]
-}

package/vitest.config.ts

@@ -1,20 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
-
-const here = dirname(fileURLToPath(import.meta.url));
-const root = resolve(here, "../..");
-
-export default {
-  resolve: {
-    alias: {
-      "@aura3d/rendering": resolve(root, "packages/rendering/src/index.ts"),
-      "@aura3d/scene": resolve(root, "packages/scene/src/index.ts"),
-      "@aura3d/math": resolve(root, "packages/math/src/index.ts"),
-      "@aura3d/core": resolve(root, "packages/core/src/index.ts")
-    }
-  },
-  test: {
-    environment: "node",
-    include: [resolve(root, "tests/unit/rendering/**/*.test.ts"), resolve(root, "tests/unit/debug/rendering-diagnostics.test.ts")]
-  }
-};