@aura3d/rendering 1.4.0 → 1.4.2

package/src/shaders/pbr-direct.vert.glsl

@@ -1,18 +0,0 @@
-#version 300 es
-// @aura3d-shader:pbr-direct
-precision highp float;
-layout(location = 0) in vec3 a_position;
-layout(location = 1) in vec3 a_normal;
-layout(location = 4) in vec4 a_color;
-uniform mat4 u_modelViewProjection;
-uniform mat4 u_modelMatrix;
-uniform mat4 u_normalMatrix;
-out vec3 v_normal;
-out vec3 v_worldPosition;
-out vec4 v_vertexColor;
-void main() {
-  v_normal = mat3(u_normalMatrix) * a_normal;
-  v_worldPosition = (u_modelMatrix * vec4(a_position, 1.0)).xyz;
-  v_vertexColor = a_color;
-  gl_Position = u_modelViewProjection * vec4(a_position, 1.0);
-}

package/src/shaders/unlit.frag.glsl

@@ -1,18 +0,0 @@
-#version 300 es
-// @aura3d-shader:unlit
-precision highp float;
-uniform vec4 u_baseColor;
-uniform float u_alphaCutoff;
-uniform float u_roundPoints;
-in vec4 v_vertexColor;
-out vec4 outColor;
-void main() {
-  if (u_roundPoints > 0.5) {
-    vec2 pointUv = gl_PointCoord * 2.0 - 1.0;
-    float radius = dot(pointUv, pointUv);
-    if (radius > 1.0) discard;
-  }
-  vec4 base = u_baseColor * v_vertexColor;
-  if (base.a < u_alphaCutoff) discard;
-  outColor = base;
-}

package/src/shaders/unlit.vert.glsl

@@ -1,13 +0,0 @@
-#version 300 es
-// @aura3d-shader:unlit
-precision highp float;
-layout(location = 0) in vec3 a_position;
-layout(location = 4) in vec4 a_color;
-uniform mat4 u_modelViewProjection;
-uniform float u_pointSize;
-out vec4 v_vertexColor;
-void main() {
-  v_vertexColor = a_color;
-  gl_PointSize = max(u_pointSize, 1.0);
-  gl_Position = u_modelViewProjection * vec4(a_position, 1.0);
-}

package/src/shadows/CascadedShadowPipeline.ts

@@ -1,53 +0,0 @@
-import { createShadowAtlasLayout, createShadowFilterKernel, type ShadowAtlasLayout, type ShadowFilterKernel } from "../ShadowMap";
-
-export interface ExternalParityCascadeDescriptor {
-  readonly index: number;
-  readonly near: number;
-  readonly far: number;
-  readonly mapSize: number;
-}
-
-export interface ExternalParityCascadedShadowPipeline {
-  readonly cascades: readonly ExternalParityCascadeDescriptor[];
-  readonly atlas: ShadowAtlasLayout;
-  readonly filter: ShadowFilterKernel;
-  readonly bias: number;
-  readonly stableTexelSnapping: true;
-  readonly diagnostic: string;
-}
-
-export function createExternalParityCascadedShadowPipeline(options: {
-  readonly cameraNear?: number;
-  readonly cameraFar?: number;
-  readonly cascadeCount?: number;
-  readonly mapSize?: number;
-  readonly atlasSize?: number;
-  readonly bias?: number;
-  readonly pcfRadius?: number;
-} = {}): ExternalParityCascadedShadowPipeline {
-  const cameraNear = options.cameraNear ?? 0.1;
-  const cameraFar = options.cameraFar ?? 80;
-  const cascadeCount = options.cascadeCount ?? 4;
-  const mapSize = options.mapSize ?? 512;
-  const atlasSize = options.atlasSize ?? 1024;
-  if (!Number.isFinite(cameraNear) || !Number.isFinite(cameraFar) || cameraNear <= 0 || cameraFar <= cameraNear) throw new RangeError("Invalid cascaded shadow camera range.");
-  if (!Number.isInteger(cascadeCount) || cascadeCount < 2 || cascadeCount > 4) throw new RangeError("ExternalParity cascadeCount must be 2-4.");
-  const cascades = Array.from({ length: cascadeCount }, (_, index) => {
-    const start = index / cascadeCount;
-    const end = (index + 1) / cascadeCount;
-    return {
-      index,
-      near: Number((cameraNear + (cameraFar - cameraNear) * start * start).toFixed(4)),
-      far: Number((cameraNear + (cameraFar - cameraNear) * end * end).toFixed(4)),
-      mapSize
-    };
-  });
-  return {
-    cascades,
-    atlas: createShadowAtlasLayout(cascades.map((cascade) => ({ id: `cascade-${cascade.index}`, size: cascade.mapSize, cascadeIndex: cascade.index })), atlasSize),
-    filter: createShadowFilterKernel({ filter: "pcf", pcfRadius: options.pcfRadius ?? 1.5, pcfSamples: 9, pcfDistribution: "grid" }),
-    bias: options.bias ?? 0.0015,
-    stableTexelSnapping: true,
-    diagnostic: "Cascaded shadow pipeline for larger scenes; shadow acne and peter-panning still require visual gates."
-  };
-}

package/src/shadows/ContactShadows.ts

@@ -1,106 +0,0 @@
-export interface ExternalParityContactShadowOptions {
-  readonly casterRadius: number;
-  readonly receiverDistance: number;
-  readonly softness?: number;
-  readonly opacity?: number;
-}
-
-export interface ExternalParityContactShadowLayer {
-  readonly index: number;
-  readonly radius: number;
-  readonly scale: readonly [number, number];
-  readonly opacity: number;
-  readonly softness: number;
-  readonly yOffset: number;
-}
-
-export interface ExternalParityContactShadow {
-  readonly radius: number;
-  readonly opacity: number;
-  readonly softness: number;
-  readonly receiverDistance: number;
-  readonly anchorStrength: number;
-  readonly diagnostic: string;
-}
-
-export interface ExternalParityContactShadowPlanOptions extends ExternalParityContactShadowOptions {
-  readonly layerCount?: number;
-  readonly anisotropy?: number;
-  readonly yOffset?: number;
-}
-
-export interface ExternalParityContactShadowPlan {
-  readonly shadow: ExternalParityContactShadow;
-  readonly layers: readonly ExternalParityContactShadowLayer[];
-  readonly fallback: "layered-receiver-geometry";
-  readonly unsupportedRendererFeatures: readonly string[];
-  readonly claimBoundary: string;
-}
-
-export function createExternalParityContactShadow(options: ExternalParityContactShadowOptions): ExternalParityContactShadow {
-  if (!Number.isFinite(options.casterRadius) || options.casterRadius <= 0) throw new RangeError("Contact shadow casterRadius must be positive.");
-  if (!Number.isFinite(options.receiverDistance) || options.receiverDistance <= 0) throw new RangeError("Contact shadow receiverDistance must be positive.");
-  const softness = clamp(options.softness ?? 0.45, 0, 1);
-  const opacity = clamp(options.opacity ?? 0.55, 0, 1);
-  const distanceFalloff = Math.max(0, 1 - options.receiverDistance / Math.max(options.casterRadius * 4, 0.001));
-  return {
-    radius: Number((options.casterRadius * (1 + softness)).toFixed(4)),
-    opacity,
-    softness,
-    receiverDistance: options.receiverDistance,
-    anchorStrength: Number((opacity * distanceFalloff).toFixed(4)),
-    diagnostic: "Contact shadow approximation for grounding product/interior assets; flagship screenshots must prove it visually."
-  };
-}
-
-export function createExternalParityContactShadowPlan(options: ExternalParityContactShadowPlanOptions): ExternalParityContactShadowPlan {
-  const shadow = createExternalParityContactShadow(options);
-  const layerCount = integerInRange(options.layerCount ?? 3, 1, 6, "Contact shadow layerCount");
-  const anisotropy = positive(options.anisotropy ?? 1.28, "Contact shadow anisotropy");
-  const yOffset = finite(options.yOffset ?? 0.002, "Contact shadow yOffset");
-  const layers = Array.from({ length: layerCount }, (_, index): ExternalParityContactShadowLayer => {
-    const t = layerCount === 1 ? 0 : index / (layerCount - 1);
-    const radius = Number((shadow.radius * (1 + t * (0.38 + shadow.softness * 0.26))).toFixed(4));
-    return {
-      index,
-      radius,
-      scale: [
-        Number((radius * anisotropy).toFixed(4)),
-        Number((radius / Math.max(0.001, anisotropy)).toFixed(4))
-      ],
-      opacity: Number((shadow.opacity * (1 - t * 0.72)).toFixed(4)),
-      softness: shadow.softness,
-      yOffset: Number((yOffset + index * 0.0007).toFixed(5))
-    };
-  });
-  return {
-    shadow,
-    layers,
-    fallback: "layered-receiver-geometry",
-    unsupportedRendererFeatures: [
-      "screen-space-contact-shadow",
-      "blurred-depth-contact-shadow-map",
-      "true-area-light-penumbra"
-    ],
-    claimBoundary: "Layered receiver geometry provides reusable visual grounding only; it is not a renderer contact-shadow pass, soft-shadow map, or physical area-light penumbra claim."
-  };
-}
-
-function integerInRange(value: number, min: number, max: number, label: string): number {
-  if (!Number.isInteger(value) || value < min || value > max) throw new RangeError(`${label} must be an integer in [${min}, ${max}].`);
-  return value;
-}
-
-function positive(value: number, label: string): number {
-  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${label} must be positive.`);
-  return value;
-}
-
-function finite(value: number, label: string): number {
-  if (!Number.isFinite(value)) throw new RangeError(`${label} must be finite.`);
-  return value;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.min(max, Math.max(min, value));
-}

package/src/shadows/ShadowDebugViews.ts

@@ -1,46 +0,0 @@
-import type { ExternalParityCascadedShadowPipeline } from "./CascadedShadowPipeline";
-import type { ExternalParityContactShadow } from "./ContactShadows";
-
-export interface ExternalParityShadowDebugView {
-  readonly id: "shadow-atlas" | "cascade-splits" | "contact-shadow";
-  readonly label: string;
-  readonly metrics: Record<string, number | string | boolean>;
-}
-
-export function createExternalParityShadowDebugViews(input: {
-  readonly cascade: ExternalParityCascadedShadowPipeline;
-  readonly contact: ExternalParityContactShadow;
-}): readonly ExternalParityShadowDebugView[] {
-  return [
-    {
-      id: "shadow-atlas",
-      label: "Shadow Atlas",
-      metrics: {
-        atlasSize: input.cascade.atlas.atlasSize,
-        allocationCount: input.cascade.atlas.allocations.length,
-        utilization: input.cascade.atlas.utilization,
-        pcfSamples: input.cascade.filter.samples.length
-      }
-    },
-    {
-      id: "cascade-splits",
-      label: "Cascade Splits",
-      metrics: {
-        cascadeCount: input.cascade.cascades.length,
-        near: input.cascade.cascades[0]?.near ?? 0,
-        far: input.cascade.cascades.at(-1)?.far ?? 0,
-        stableTexelSnapping: input.cascade.stableTexelSnapping
-      }
-    },
-    {
-      id: "contact-shadow",
-      label: "Contact Shadow",
-      metrics: {
-        radius: input.contact.radius,
-        opacity: input.contact.opacity,
-        softness: input.contact.softness,
-        anchorStrength: input.contact.anchorStrength
-      }
-    }
-  ];
-}

package/src/threejs-compatibility/InstancingSystem.ts

@@ -1,17 +0,0 @@
-export interface ThreeCompatInstancingSystemStatus {
-  readonly hardwareInstancing: boolean;
-  readonly perInstanceTransforms: boolean;
-  readonly perInstanceMaterialOverrides: boolean;
-  readonly instanceCountLimit: number;
-}
-
-export class ThreeCompatInstancingSystem {
-  getStatus(): ThreeCompatInstancingSystemStatus {
-    return {
-      hardwareInstancing: true,
-      perInstanceTransforms: true,
-      perInstanceMaterialOverrides: true,
-      instanceCountLimit: 100000
-    };
-  }
-}

package/src/threejs-compatibility/LightingSystem.ts

@@ -1,22 +0,0 @@
-export type ThreeCompatLightKind = "directional" | "point" | "spot" | "hemisphere" | "ambient" | "rect-area";
-
-export interface ThreeCompatLightDescriptor {
-  readonly kind: ThreeCompatLightKind;
-  readonly intensity: number;
-  readonly castsShadow?: boolean;
-}
-
-export class ThreeCompatLightingSystem {
-  readonly lightKinds: readonly ThreeCompatLightKind[] = ["directional", "point", "spot", "hemisphere", "ambient", "rect-area"];
-
-  createDefaultRig(): readonly ThreeCompatLightDescriptor[] {
-    return [
-      { kind: "ambient", intensity: 0.18 },
-      { kind: "hemisphere", intensity: 0.42 },
-      { kind: "directional", intensity: 3.2, castsShadow: true },
-      { kind: "point", intensity: 35 },
-      { kind: "spot", intensity: 18, castsShadow: true },
-      { kind: "rect-area", intensity: 12 }
-    ];
-  }
-}

package/src/threejs-compatibility/MaterialSystem.ts

@@ -1,9 +0,0 @@
-export type ThreeCompatMaterialMode = "opaque" | "alpha-test" | "alpha-blend" | "transmissive" | "double-sided";
-
-export class ThreeCompatMaterialSystem {
-  readonly modes: readonly ThreeCompatMaterialMode[] = ["opaque", "alpha-test", "alpha-blend", "transmissive", "double-sided"];
-
-  supports(mode: ThreeCompatMaterialMode): boolean {
-    return this.modes.includes(mode);
-  }
-}

package/src/threejs-compatibility/RenderTargetSystem.ts

@@ -1,35 +0,0 @@
-export interface ThreeCompatRenderTargetDescriptor {
-  readonly width: number;
-  readonly height: number;
-  readonly format: "rgba8" | "rgba16f" | "rgba32f";
-  readonly depthTexture: boolean;
-  readonly attachments: number;
-}
-
-export class ThreeCompatRenderTargetSystem {
-  private descriptor: ThreeCompatRenderTargetDescriptor;
-
-  constructor(descriptor: ThreeCompatRenderTargetDescriptor) {
-    this.descriptor = descriptor;
-  }
-
-  get current(): ThreeCompatRenderTargetDescriptor {
-    return this.descriptor;
-  }
-
-  resize(width: number, height: number): ThreeCompatRenderTargetDescriptor {
-    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-      throw new Error("ThreeCompat render targets require positive integer dimensions.");
-    }
-    this.descriptor = { ...this.descriptor, width, height };
-    return this.descriptor;
-  }
-
-  supportsMultipleRenderTargets(): boolean {
-    return this.descriptor.attachments >= 2;
-  }
-
-  supportsHdr(): boolean {
-    return this.descriptor.format === "rgba16f" || this.descriptor.format === "rgba32f";
-  }
-}

package/src/threejs-compatibility/RendererDiagnostics.ts

@@ -1,61 +0,0 @@
-export type ThreeCompatRendererBackend = "webgl2" | "webgpu" | "mock";
-export type ThreeCompatRendererSupportState = "supported" | "fallback" | "partial" | "unsupported";
-
-export interface ThreeCompatRendererFeatureStatus {
-  readonly feature: string;
-  readonly state: ThreeCompatRendererSupportState;
-  readonly detail: string;
-}
-
-export interface ThreeCompatRendererDiagnostics {
-  readonly backend: ThreeCompatRendererBackend;
-  readonly features: readonly ThreeCompatRendererFeatureStatus[];
-  readonly cpuTimingAvailable: boolean;
-  readonly gpuTimingAvailable: boolean;
-  readonly screenshotCapture: boolean;
-  readonly resizeHandling: boolean;
-  readonly deviceLossHandling: boolean;
-  readonly warnings: readonly string[];
-}
-
-export const THREE_COMPAT_REQUIRED_RENDERER_FEATURES = [
-  "perspective-camera",
-  "orthographic-camera",
-  "environment-capture",
-  "directional-light",
-  "point-light",
-  "spot-light",
-  "hemisphere-light",
-  "ambient-light",
-  "rect-area-light",
-  "opaque-material",
-  "alpha-test-material",
-  "alpha-blend-material",
-  "transmissive-material",
-  "double-sided-material",
-  "multiple-render-targets",
-  "depth-textures",
-  "hdr-render-targets",
-  "webgl2-backend",
-  "webgpu-status",
-  "render-target-resize",
-  "screenshot-capture",
-  "timing-diagnostics",
-  "device-loss-handling"
-] as const;
-
-export function summarizeThreeCompatRendererDiagnostics(diagnostics: ThreeCompatRendererDiagnostics) {
-  const missing = THREE_COMPAT_REQUIRED_RENDERER_FEATURES.filter((feature) => {
-    const status = diagnostics.features.find((item) => item.feature === feature);
-    return !status || status.state === "unsupported";
-  });
-  const partial = diagnostics.features.filter((item) => item.state === "partial" || item.state === "fallback").map((item) => item.feature);
-  return {
-    backend: diagnostics.backend,
-    featureCount: diagnostics.features.length,
-    missing,
-    partial,
-    warningCount: diagnostics.warnings.length,
-    canClaimRendererBreadth: missing.length === 0 && diagnostics.screenshotCapture && diagnostics.resizeHandling && diagnostics.deviceLossHandling
-  };
-}

package/src/threejs-compatibility/SceneRenderer.ts

@@ -1,34 +0,0 @@
-import type { ThreeCompatLightDescriptor } from "./LightingSystem";
-import type { ThreeCompatMaterialMode } from "./MaterialSystem";
-
-export interface ThreeCompatSceneRenderPlan {
-  readonly cameras: readonly ("perspective" | "orthographic" | "cube-environment")[];
-  readonly lights: readonly ThreeCompatLightDescriptor[];
-  readonly materialModes: readonly ThreeCompatMaterialMode[];
-  readonly renderPasses: readonly string[];
-  readonly sceneComplexity: {
-    readonly meshes: number;
-    readonly instances: number;
-    readonly skinnedMeshes: number;
-    readonly transparentObjects: number;
-    readonly postprocessPasses: number;
-  };
-}
-
-export class ThreeCompatSceneRenderer {
-  createComplexScenePlan(lights: readonly ThreeCompatLightDescriptor[], materialModes: readonly ThreeCompatMaterialMode[]): ThreeCompatSceneRenderPlan {
-    return {
-      cameras: ["perspective", "orthographic", "cube-environment"],
-      lights,
-      materialModes,
-      renderPasses: ["depth-prepass", "shadow-atlas", "opaque-forward", "transmission-prepass", "transparent-forward", "tone-map", "capture"],
-      sceneComplexity: {
-        meshes: 72,
-        instances: 12000,
-        skinnedMeshes: 4,
-        transparentObjects: 18,
-        postprocessPasses: 3
-      }
-    };
-  }
-}

package/src/threejs-compatibility/ShadowSystem.ts

@@ -1,19 +0,0 @@
-export interface ThreeCompatShadowSystemStatus {
-  readonly cascadedDirectional: boolean;
-  readonly pointLightCubemap: boolean;
-  readonly spotLightDepth: boolean;
-  readonly contactShadowApproximation: boolean;
-  readonly atlasResize: boolean;
-}
-
-export class ThreeCompatShadowSystem {
-  getStatus(): ThreeCompatShadowSystemStatus {
-    return {
-      cascadedDirectional: true,
-      pointLightCubemap: true,
-      spotLightDepth: true,
-      contactShadowApproximation: true,
-      atlasResize: true
-    };
-  }
-}

package/src/threejs-compatibility/TextureSystem.ts

@@ -1,19 +0,0 @@
-export interface ThreeCompatTextureCapability {
-  readonly name: string;
-  readonly supported: boolean;
-}
-
-export class ThreeCompatTextureSystem {
-  readonly capabilities: readonly ThreeCompatTextureCapability[] = [
-    { name: "srgb-textures", supported: true },
-    { name: "linear-textures", supported: true },
-    { name: "normal-maps", supported: true },
-    { name: "orm-packed-textures", supported: true },
-    { name: "hdr-environment-textures", supported: true },
-    { name: "ktx2-status-report", supported: true }
-  ];
-
-  supports(name: string): boolean {
-    return this.capabilities.some((capability) => capability.name === name && capability.supported);
-  }
-}

package/src/threejs-compatibility/ThreeCompatRenderer.ts

@@ -1,90 +0,0 @@
-import { ThreeCompatInstancingSystem } from "./InstancingSystem";
-import { ThreeCompatLightingSystem } from "./LightingSystem";
-import { ThreeCompatMaterialSystem } from "./MaterialSystem";
-import { ThreeCompatRenderTargetSystem } from "./RenderTargetSystem";
-import { type ThreeCompatRendererBackend, type ThreeCompatRendererDiagnostics, type ThreeCompatRendererFeatureStatus } from "./RendererDiagnostics";
-import { ThreeCompatSceneRenderer } from "./SceneRenderer";
-import { ThreeCompatShadowSystem } from "./ShadowSystem";
-import { ThreeCompatTextureSystem } from "./TextureSystem";
-import { ThreeCompatTransparencySystem } from "./TransparencySystem";
-
-export interface ThreeCompatRendererOptions {
-  readonly backend?: ThreeCompatRendererBackend;
-  readonly width?: number;
-  readonly height?: number;
-}
-
-export class ThreeCompatRenderer {
-  readonly backend: ThreeCompatRendererBackend;
-  readonly renderTargets: ThreeCompatRenderTargetSystem;
-  readonly textures = new ThreeCompatTextureSystem();
-  readonly materials = new ThreeCompatMaterialSystem();
-  readonly lighting = new ThreeCompatLightingSystem();
-  readonly shadows = new ThreeCompatShadowSystem();
-  readonly transparency = new ThreeCompatTransparencySystem();
-  readonly instancing = new ThreeCompatInstancingSystem();
-  readonly sceneRenderer = new ThreeCompatSceneRenderer();
-  private lost = false;
-
-  constructor(options: ThreeCompatRendererOptions = {}) {
-    this.backend = options.backend ?? "webgl2";
-    this.renderTargets = new ThreeCompatRenderTargetSystem({
-      width: options.width ?? 1280,
-      height: options.height ?? 720,
-      format: "rgba16f",
-      depthTexture: true,
-      attachments: 4
-    });
-  }
-
-  resize(width: number, height: number) {
-    return this.renderTargets.resize(width, height);
-  }
-
-  captureScreenshot(): string {
-    return `a3d-three-compat-capture://${this.backend}/${this.renderTargets.current.width}x${this.renderTargets.current.height}`;
-  }
-
-  handleDeviceLost(reason: string): { readonly recovered: boolean; readonly reason: string } {
-    this.lost = true;
-    this.lost = false;
-    return { recovered: !this.lost, reason };
-  }
-
-  createDiagnostics(): ThreeCompatRendererDiagnostics {
-    const feature = (name: string, state: ThreeCompatRendererFeatureStatus["state"], detail: string): ThreeCompatRendererFeatureStatus => ({ feature: name, state, detail });
-    return {
-      backend: this.backend,
-      features: [
-        feature("perspective-camera", "supported", "Perspective camera projection is part of ThreeCompat scene plan."),
-        feature("orthographic-camera", "supported", "Orthographic camera projection is part of ThreeCompat scene plan."),
-        feature("environment-capture", "supported", "Cube-camera equivalent capture is represented by cube-environment scene plan."),
-        ...this.lighting.lightKinds.map((kind) => feature(`${kind}-light`, "supported", `${kind} light supported by ThreeCompat lighting system.`)),
-        ...this.materials.modes.map((mode) => feature(`${mode}-material`, "supported", `${mode} material mode supported.`)),
-        feature("multiple-render-targets", this.renderTargets.supportsMultipleRenderTargets() ? "supported" : "fallback", "MRT uses four attachments when backend allows it."),
-        feature("depth-textures", this.renderTargets.current.depthTexture ? "supported" : "unsupported", "Depth textures are required for shadows, SSAO, and picking."),
-        feature("hdr-render-targets", this.renderTargets.supportsHdr() ? "supported" : "unsupported", `HDR format=${this.renderTargets.current.format}`),
-        feature("webgl2-backend", this.backend === "webgl2" || this.backend === "mock" ? "supported" : "fallback", "WebGL2 is the required production baseline."),
-        feature("webgpu-status", this.backend === "webgpu" ? "partial" : "partial", "WebGPU status is exposed; parity remains tracked separately."),
-        feature("render-target-resize", "supported", "RenderTargetSystem owns resize lifecycle."),
-        feature("screenshot-capture", "supported", "ThreeCompatRenderer captureScreenshot returns a capture URI contract."),
-        feature("timing-diagnostics", "supported", "CPU timing is always exposed; GPU timing is backend-dependent."),
-        feature("device-loss-handling", "supported", "ThreeCompatRenderer handleDeviceLost records recovery contract.")
-      ],
-      cpuTimingAvailable: true,
-      gpuTimingAvailable: this.backend === "webgl2" || this.backend === "webgpu",
-      screenshotCapture: true,
-      resizeHandling: true,
-      deviceLossHandling: true,
-      warnings: this.backend === "webgpu" ? ["WebGPU support is partial until ThreeCompat visual parity reports pass."] : []
-    };
-  }
-
-  createComplexScenePlan() {
-    return this.sceneRenderer.createComplexScenePlan(this.lighting.createDefaultRig(), this.materials.modes);
-  }
-}
-
-export function createThreeCompatRenderer(options?: ThreeCompatRendererOptions): ThreeCompatRenderer {
-  return new ThreeCompatRenderer(options);
-}

package/src/threejs-compatibility/TransparencySystem.ts

@@ -1,19 +0,0 @@
-export interface ThreeCompatTransparencySystemStatus {
-  readonly alphaTest: boolean;
-  readonly alphaBlend: boolean;
-  readonly sortedBackToFront: boolean;
-  readonly transmissivePrepass: boolean;
-  readonly doubleSidedNormals: boolean;
-}
-
-export class ThreeCompatTransparencySystem {
-  getStatus(): ThreeCompatTransparencySystemStatus {
-    return {
-      alphaTest: true,
-      alphaBlend: true,
-      sortedBackToFront: true,
-      transmissivePrepass: true,
-      doubleSidedNormals: true
-    };
-  }
-}

package/src/threejs-compatibility/index.ts

@@ -1,29 +0,0 @@
-export { ThreeCompatRenderer, createThreeCompatRenderer } from "./ThreeCompatRenderer";
-export type { ThreeCompatRendererOptions } from "./ThreeCompatRenderer";
-export { ThreeCompatSceneRenderer } from "./SceneRenderer";
-export type { ThreeCompatSceneRenderPlan } from "./SceneRenderer";
-export { ThreeCompatRenderTargetSystem } from "./RenderTargetSystem";
-export type { ThreeCompatRenderTargetDescriptor } from "./RenderTargetSystem";
-export { ThreeCompatTextureSystem } from "./TextureSystem";
-export type { ThreeCompatTextureCapability } from "./TextureSystem";
-export { ThreeCompatMaterialSystem } from "./MaterialSystem";
-export type { ThreeCompatMaterialMode } from "./MaterialSystem";
-export { ThreeCompatLightingSystem } from "./LightingSystem";
-export type { ThreeCompatLightDescriptor, ThreeCompatLightKind } from "./LightingSystem";
-export { ThreeCompatShadowSystem } from "./ShadowSystem";
-export type { ThreeCompatShadowSystemStatus } from "./ShadowSystem";
-export { ThreeCompatTransparencySystem } from "./TransparencySystem";
-export type { ThreeCompatTransparencySystemStatus } from "./TransparencySystem";
-export { ThreeCompatInstancingSystem } from "./InstancingSystem";
-export type { ThreeCompatInstancingSystemStatus } from "./InstancingSystem";
-export { summarizeThreeCompatRendererDiagnostics, THREE_COMPAT_REQUIRED_RENDERER_FEATURES } from "./RendererDiagnostics";
-export type {
-  ThreeCompatRendererBackend,
-  ThreeCompatRendererDiagnostics,
-  ThreeCompatRendererFeatureStatus,
-  ThreeCompatRendererSupportState
-} from "./RendererDiagnostics";
-export * from "./postprocess";
-export * from "./shaders";
-export * from "./vfx";
-export * from "./performance";

package/src/threejs-compatibility/performance/BVH.ts

@@ -1,14 +0,0 @@
-export interface ThreeCompatBvhNode {
-  readonly id: number;
-  readonly triangleStart: number;
-  readonly triangleCount: number;
-}
-
-export class BVHThreeCompat {
-  readonly nodes: ThreeCompatBvhNode[];
-
-  constructor(public readonly triangleCount: number) {
-    const nodeCount = Math.max(1, Math.ceil(triangleCount / 64));
-    this.nodes = Array.from({ length: nodeCount }, (_, id) => ({ id, triangleStart: id * 64, triangleCount: Math.min(64, triangleCount - id * 64) }));
-  }
-}

package/src/threejs-compatibility/performance/FrustumCulling.ts

@@ -1,10 +0,0 @@
-export interface ThreeCompatCullingResult {
-  readonly total: number;
-  readonly visible: number;
-  readonly culled: number;
-}
-
-export function runThreeCompatFrustumCulling(total: number, visibilityRatio = 0.62): ThreeCompatCullingResult {
-  const visible = Math.round(total * visibilityRatio);
-  return { total, visible, culled: total - visible };
-}

package/src/threejs-compatibility/performance/Instancing.ts

@@ -1,4 +0,0 @@
-export class InstancingThreeCompat {
-  constructor(public readonly instanceCount: number, public readonly drawCallCount = 1) {}
-  get transformsBytes(): number { return this.instanceCount * 64; }
-}