@equinor/videx-3d 1.1.1 → 2.0.0

package/dist/types/rendering/gpu-timer.d.ts

@@ -0,0 +1,46 @@
+import { WebGLRenderer } from 'three';
+/**
+ * Tiny GPU timer for WebGL2 built on `EXT_disjoint_timer_query_webgl2`.
+ *
+ * DEBUG-ONLY instrumentation: it brackets named, non-overlapping segments with
+ * `TIME_ELAPSED` queries and reads the results back asynchronously (a few frames
+ * later), reporting a smoothed millisecond figure per segment. Because the GPU runs
+ * behind the CPU, results are never available the same frame they are issued, so a
+ * small ring of queries per segment is kept in flight.
+ *
+ * Only one timer query can be active at a time per spec, so {@link begin}/{@link end}
+ * calls must be strictly sequential (never nested). All methods are no-ops when the
+ * extension is unavailable (older browsers, or the WebGPU renderer), so call sites
+ * can leave instrumentation in place unconditionally.
+ *
+ * This is measurement only — it issues no draws and mutates no render state — so it
+ * does not affect the rendered result and is safe to leave compiled in behind a flag.
+ *
+ * @group Rendering
+ */
+export declare class GpuTimer {
+    private gl;
+    private ext;
+    private segments;
+    private pool;
+    private active;
+    private activeSeg;
+    /** Whether GPU timing is available in this context. */
+    get supported(): boolean;
+    constructor(renderer: WebGLRenderer);
+    /** Begin timing a segment. No-op if unsupported or another segment is active. */
+    begin(label: string): void;
+    /** End timing the current segment. */
+    end(): void;
+    /**
+     * Harvest finished queries and update the smoothed timings. Call once per frame
+     * (e.g. at the top of the host pass's render). Disjoint frames (GPU context
+     * disruption) are discarded.
+     */
+    poll(): void;
+    /** Smoothed elapsed milliseconds for a segment, or -1 if no result yet. */
+    get(label: string): number;
+    /** Snapshot of every segment's smoothed timing in milliseconds. */
+    snapshot(): Record<string, number>;
+    dispose(): void;
+}

package/dist/types/rendering/index.d.ts

@@ -1,2 +1,8 @@
 export * from './fullscreen-renderer';
-export * from './render-passes';
+export * from './gpu-timer';
+export * from './oit-material';
+export * from './OitMaterial';
+export * from './Pass';
+export * from './passes';
+export * from './rendering-state';
+export * from './RenderingPipeline';

package/dist/types/rendering/oit-material.d.ts

@@ -0,0 +1,122 @@
+import { IUniform, Material, ShaderMaterial, Side, Texture, Vector2 } from 'three';
+/**
+ * The OIT render passes a material provides a variant for.
+ * - `depthMin`: min view-space linear depth pre-pass (front-layer detection)
+ * - `accum`: single-buffer weighted-blended OIT tail (b-weighted, carries coverage)
+ * - `front`: exact depth-peeled front layer (alpha-over)
+ * - `occlusion`: optional depth-only stamp that writes depth where the surface's own
+ *   alpha clears `oitOcclusionThreshold` (used to occlude annotation labels). Off by
+ *   default; its program is only compiled by Three when the pass actually renders it.
+ */
+export type OitPass = 'depthMin' | 'accum' | 'front' | 'occlusion';
+/** The set of per-pass variant materials used by the OITRenderPass. */
+export type OitVariants = Record<OitPass, Material>;
+/** The OIT uniforms shared across a material's variants and set by the pass. */
+export type OitUniforms = {
+    oitDepthFar: IUniform<number>;
+    oitScreenSize: IUniform<Vector2>;
+    oitMinDepthTexture: IUniform<Texture | null>;
+    oitSkipFront: IUniform<number>;
+    oitOcclusionThreshold: IUniform<number>;
+};
+/**
+ * A material that can participate in the {@link OITRenderPass} hybrid pipeline.
+ * Implemented by library materials (via {@link attachOitVariants}) and by patched
+ * stock / user materials (via {@link makeOitCompatible}).
+ */
+export interface OitCapableMaterial {
+    /** Returns the lazily-built per-pass variant materials (shared uniforms). */
+    getOitVariants(): OitVariants;
+    /** Returns the OIT uniforms object the pass updates each frame. */
+    getOitUniforms(): OitUniforms;
+}
+/** Options for making a material OIT-compatible. */
+export type OitMaterialOptions = {
+    /**
+     * Force a specific `side` on all variants (e.g. `DoubleSide` for surfaces so back
+     * faces contribute to the tail). Defaults to the base material's side.
+     */
+    side?: Side;
+    /**
+     * Names of properties on the material that hold uniform containers (objects of
+     * `IUniform`) which should be shared *by reference* with each per-pass variant.
+     * `ShaderMaterial` variants already share `uniforms`, but non-`ShaderMaterial`
+     * materials are cloned, so any custom uniform object they read in
+     * `onBeforeCompile` (e.g. a `uniforms` field used for slicing) must be listed
+     * here for live per-frame updates to reach the variants.
+     */
+    shareUniforms?: string[];
+    /**
+     * Names of **value** properties to keep in sync from the base material onto the
+     * per-pass variants every frame. Only relevant for stock/built-in materials, whose
+     * variants are *cloned* and would otherwise snapshot their appearance at build time
+     * (`ShaderMaterial` variants share `uniforms` and are always live, so this is
+     * ignored for them).
+     *
+     * Restricted to value properties that do **not** affect the compiled program:
+     * - primitives (e.g. `metalness`, `roughness`, `emissiveIntensity`), and
+     * - copyable value objects with a `.copy()` method (e.g. `color`, `emissive` —
+     *   `Color`; or `Vector2/3/4`), which are copied in place (no allocation, no
+     *   recompile).
+     *
+     * Do **not** list program-affecting properties here (textures such as `map`,
+     * `vertexColors`, anything that toggles a shader `#define`) — changing those needs
+     * a recompile and is intentionally unsupported through this fast path. `opacity` is
+     * always kept live and need not be listed. Use {@link COMMON_OIT_SYNC_PROPS} for a
+     * sensible default set.
+     *
+     * @example
+     * ```ts
+     * makeOitCompatible(material, { syncProperties: ['color', 'metalness'] });
+     * // or spread the common set:
+     * makeOitCompatible(material, { syncProperties: [...COMMON_OIT_SYNC_PROPS] });
+     * ```
+     */
+    syncProperties?: string[];
+};
+/**
+ * A convenient default set of common appearance properties to pass as
+ * {@link OitMaterialOptions.syncProperties} so runtime changes (e.g. recoloring) are
+ * reflected through the OIT passes for cloned built-in materials. Properties not
+ * present on a given material are ignored.
+ *
+ * @group Rendering
+ */
+export declare const COMMON_OIT_SYNC_PROPS: readonly ["color", "emissive", "emissiveIntensity", "metalness", "roughness"];
+/** Type guard for {@link OitCapableMaterial}. */
+export declare function isOitCapable(material: Material | null | undefined): material is Material & OitCapableMaterial;
+/**
+ * Make a library `ShaderMaterial` OIT-capable. The material's fragment shader is
+ * expected to already `#include` `oit.glsl` and call `oitProcess(gl_FragColor)`
+ * guarded by `#ifdef USE_OIT` (a no-op in the default pipeline). This adds the OIT
+ * uniforms to the material and attaches the per-pass variant machinery.
+ *
+ * @param material - the library ShaderMaterial to extend
+ * @param options - optional overrides (e.g. `side`)
+ * @returns the same material, typed as {@link OitCapableMaterial}
+ *
+ * @group Rendering
+ * @see {@link makeOitCompatible}
+ */
+export declare function attachOitVariants<T extends ShaderMaterial>(material: T, options?: OitMaterialOptions): T & OitCapableMaterial;
+/**
+ * Make any stock Three.js material or user-authored material OIT-compatible by
+ * patching its shaders at compile time (via `onBeforeCompile`) to include the OIT
+ * logic, and attaching the per-pass variant machinery.
+ *
+ * Works with lit built-in materials (which provide `vViewPosition`) and with
+ * materials lacking it (e.g. `LineBasicMaterial`), in which case `vViewPosition` is
+ * injected automatically. All injected code is guarded by `#ifdef USE_OIT`, so the
+ * base program is unchanged outside the OIT pipeline.
+ *
+ * Note: targets materials compiled by Three.js (built-ins, `ShaderMaterial`). Raw
+ * `RawShaderMaterial` (no Three.js shader prelude) is not auto-patched.
+ *
+ * @param material - the material to patch
+ * @param options - optional overrides (e.g. `side`)
+ * @returns the same material, typed as {@link OitCapableMaterial}
+ *
+ * @group Rendering
+ * @see {@link attachOitVariants}
+ */
+export declare function makeOitCompatible<T extends Material>(material: T, options?: OitMaterialOptions): T & OitCapableMaterial;

package/dist/types/{components/Annotations/annotations-renderer.d.ts → rendering/passes/AnnotationsPass.d.ts}

@@ -1,7 +1,8 @@
 import { Camera, CanvasTexture, Clock, PerspectiveCamera, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { FullscreenRenderer } from '../../rendering/fullscreen-renderer';
-import { AnnotationInstance } from './types';
-export declare class AnnotationsRenderer {
+import { AnnotationInstance } from '../../components/Annotations/types';
+import { FullscreenRenderer } from '../fullscreen-renderer';
+import { Pass } from '../Pass';
+export declare class AnnotationsPass extends Pass {
     maxVisible: number;
     camera: PerspectiveCamera;
     clock: Clock;
@@ -12,11 +13,19 @@ export declare class AnnotationsRenderer {
     annotationsRenderTarget: WebGLRenderTarget;
     annotationsBuffer: Uint8Array;
     annotationsMaterial: ShaderMaterial;
-    fullscreenRenderer: FullscreenRenderer;
     annotationsData: AnnotationInstance[];
     isBusy: boolean;
     dataTextureNeedsUpdate: boolean;
+    fullscreenRenderer: FullscreenRenderer;
     unsubscribeListeners: () => void;
+    private prevCameraMatrix;
+    private prevPointerX;
+    private prevPointerY;
+    private prevSizeX;
+    private prevSizeY;
+    private occlusionChanged;
+    connectorTargetFrameTime: number;
+    connectorStretchSlack: number;
     constructor(camera: Camera, clock: Clock, pointer: Vector2, maxVisible?: number);
     updateAnnotationsData(buffer: Uint8Array): void;
     updateOverlayTexture(inViewSpace: AnnotationInstance[]): void;

package/dist/types/rendering/passes/FXAAPass.d.ts

@@ -0,0 +1,12 @@
+import { WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from '../Pass';
+export declare class FxaaPass extends Pass {
+    private scratch;
+    private fxaaMaterial;
+    private blitMaterial;
+    private fullscreenRenderer;
+    constructor();
+    setSize(width: number, height: number): void;
+    dispose(): void;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+}

package/dist/types/rendering/passes/OITRenderPass.d.ts

@@ -0,0 +1,282 @@
+import { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from '../Pass';
+/** Per-frame object counts for each classification, exposed for debugging. */
+export type OITRenderPassStats = {
+    /** Plain opaque renderables (not OIT-capable, not overlay). */
+    opaque: number;
+    /** OIT-capable renderables currently transparent (routed through OIT). */
+    oit: number;
+    /**
+     * OIT-capable renderables that are currently fully opaque and therefore drawn in
+     * the opaque pass as real occluders (depth-writing), bypassing the OIT passes.
+     */
+    oitOpaque: number;
+    /** Additive/glow renderables (tagged `LAYERS.EMISSIVE`), drawn before the transparent layers. */
+    emissive: number;
+    /** Always-on-top renderables (tagged `LAYERS.OVERLAY`), drawn after the transparent layers. */
+    overlay: number;
+    /** Subset of `oit` whose whole material is OIT-capable (hidden in opaque pass). */
+    oitHidden: number;
+    /** Subset of `oit` that are mixed multi-material meshes (some opaque groups). */
+    oitMixed: number;
+};
+/**
+ * Resource/accumulation counters for leak monitoring. Unlike {@link OITRenderPassStats}
+ * (per-frame object classification, which naturally varies with the camera), these
+ * track internal structures and global GPU resources that should stay *bounded* over
+ * time. Watch them while toggling the pipeline on/off (which recreates the passes): a
+ * steady climb indicates passes or GPU resources are not being disposed.
+ */
+export type OITRenderPassResources = {
+    /**
+     * Active OIT pipeline registrations on this canvas (the ref-counted
+     * {@link RenderingState} `_oitCount`). Should read 1 while a single OIT pipeline is
+     * mounted; a value that climbs each time the pipeline is recreated means a pass was
+     * acquired but never released in {@link OITRenderPass.dispose} (a real leak).
+     */
+    oitPipelines: number;
+    /**
+     * Total classification entries created since this pass instance was constructed
+     * (monotonic). Resets only when the pass itself is recreated, so it grows quickly
+     * during warm-up and should then plateau.
+     */
+    entriesTotal: number;
+    /**
+     * Classification entries created this frame (cache misses). ~0 in steady state; a
+     * persistently non-zero value means object material identities churn every frame,
+     * which also churns the cached per-pass OIT variants.
+     */
+    entriesThisFrame: number;
+    /** GPU textures currently tracked by the renderer (global; watch for unbounded growth). */
+    textures: number;
+    /** GPU geometries currently tracked by the renderer (global). */
+    geometries: number;
+    /** Compiled shader programs currently held by the renderer (global). `-1` if unavailable. */
+    programs: number;
+};
+/**
+ * Per-segment GPU timings in milliseconds, populated when {@link OITRenderPass.profile}
+ * is enabled and the platform supports timer queries. `-1` means "no result yet"
+ * (or unsupported). `tail` is the single weighted-blended OIT pass cost.
+ */
+export type OITRenderPassTimings = {
+    /** Opaque pass (step 1), including any forced-opaque OIT occluders. */
+    opaque: number;
+    /** Additive/glow emissive pass (step 1b). */
+    emissive: number;
+    /** Min-depth pre-pass (step 2). */
+    minDepth: number;
+    /** Weighted-blended OIT tail pass (step 3). */
+    tail: number;
+    /** Fullscreen tail composite (step 4). */
+    composite: number;
+    /** Exact front-layer pass (step 5). */
+    front: number;
+    /** Optional occlusion depth-stamp pass (step 5b). */
+    occlusion: number;
+    /** Optional emitter depth-stamp pass (step 1c). */
+    emitterStamp: number;
+    /** Always-on-top overlay pass (step 6). */
+    overlay: number;
+    /** Sum of the measured OIT segments above. */
+    total: number;
+};
+/**
+ * Hybrid order-independent-transparency (OIT) render pass for use with the
+ * {@link RenderingPipeline} (or any custom composer). Renders the nearest transparent
+ * layer exactly (depth-peeled, alpha-over) and the remaining layers using
+ * weighted-blended OIT (WBOIT), partitioned per-pixel in view-space linear depth.
+ *
+ * Transparency is opt-in: this pass only affects materials that are OIT-capable
+ * (library materials, or stock/user materials patched with `makeOitCompatible`).
+ * Two per-object escape-hatch layers override the default routing: `LAYERS.FORCE_OPAQUE`
+ * draws the object as a depth-writing opaque occluder (its material is temporarily
+ * forced to `depthWrite=true, transparent=false`); `LAYERS.OIT_EXCLUDED` also draws it
+ * in the opaque pass but leaves the material's own properties untouched.
+ * Additive/glow objects tagged with the `LAYERS.EMISSIVE` layer are drawn between the
+ * opaque and transparent layers (so transparent surfaces in front attenuate them);
+ * always-on-top objects tagged with the `LAYERS.OVERLAY` layer are drawn last, on top
+ * of the resolved transparency. While this pass is active it sets the per-canvas
+ * rendering state to `'oit'` so components can disable conflicting self-transparency
+ * workarounds.
+ *
+ * @example
+ * ```tsx
+ * const passes = useMemo(
+ *   () => [new OITRenderPass(scene, camera), new OutputPass()],
+ *   [scene, camera],
+ * );
+ * return <RenderingPipeline passes={passes} />;
+ * ```
+ *
+ * @group Rendering
+ * @see {@link RenderingPipeline}
+ * @see {@link makeOitCompatible}
+ */
+export declare class OITRenderPass extends Pass {
+    private scene;
+    private camera;
+    /**
+     * Debug: when true, the exact depth-peeled front layer is disabled and every
+     * transparent fragment is resolved through the weighted-blended (WBOIT) tail.
+     * Useful for isolating tail behaviour and comparing against the hybrid result.
+     */
+    skipFront: boolean;
+    /**
+     * Optional feature (default off): after the transparent OIT passes, stamp depth
+     * for transparent surfaces wherever their own alpha is at least
+     * {@link occlusionDepthThreshold}. Transparent surfaces normally write no depth, so
+     * annotation labels behind a high-but-not-full opacity surface are never occluded;
+     * enabling this makes a surface occlude labels once its alpha clears the threshold.
+     *
+     * The test is per-fragment and per-surface (each surface judged on its own alpha,
+     * not accumulated coverage), and the stamped depth uses the same encoding the
+     * {@link AnnotationsPass} already samples. Costs one extra transparent-geometry
+     * pass per frame when enabled; nothing (not even a shader compile) when off.
+     */
+    occlusionDepthStamp: boolean;
+    /** Alpha threshold (0..1) for {@link occlusionDepthStamp}. Default 0.5. */
+    occlusionDepthThreshold: number;
+    /**
+     * Optional feature (default off): stamp depth for emissive/glow emitters (objects
+     * on `LAYERS.EMISSIVE`) wherever their fragment strength is at least
+     * {@link emitterDepthThreshold}, drawn before the transparent OIT passes. This lets
+     * the dense core of an additive emitter (e.g. perforation jets) occlude transparent
+     * surfaces behind it, preventing the wash-out where a far transparent surface would
+     * otherwise dim the emitter. Surfaces in front still attenuate it.
+     *
+     * An emitter opts in by exposing a depth-only stamp material on its material's
+     * `userData.occlusionDepthMaterial` (with a `uOcclusionThreshold` uniform the pass
+     * drives). Emitters without one are simply skipped. Costs one extra emissive pass
+     * per frame when enabled; nothing when off.
+     */
+    emitterDepthStamp: boolean;
+    /** Strength threshold (0..1) for {@link emitterDepthStamp}. Default 0.5. */
+    emitterDepthThreshold: number;
+    /**
+     * When true, draws small thumbnails of the internal render targets (min-depth,
+     * accumulation) into the bottom-left of the output, for debugging.
+     * GPU-only; no pixel readback.
+     */
+    debugTargets: boolean;
+    /**
+     * When true, measures per-segment GPU time (opaque/emissive/min-depth/tail/
+     * composite/front/overlay) via timer queries and exposes it on {@link timings}. Adds a
+     * little CPU/driver overhead and lags a few frames, so it is off by default. No-op
+     * on platforms without `EXT_disjoint_timer_query_webgl2`.
+     *
+     * The most relevant figure for the transparent-geometry cost is
+     * {@link OITRenderPassTimings.tail}.
+     */
+    profile: boolean;
+    /**
+     * Per-segment GPU timings (ms) from the last completed measurement. Only updated
+     * while {@link profile} is enabled. `-1` means "no result yet" or unsupported.
+     */
+    readonly timings: OITRenderPassTimings;
+    /**
+     * Per-frame object counts for each pass, updated every {@link render}. Useful for
+     * verifying which objects are routed through OIT vs. drawn opaque/overlay.
+     */
+    readonly stats: OITRenderPassStats;
+    /**
+     * Resource/accumulation counters for leak monitoring, updated every {@link render}.
+     * See {@link OITRenderPassResources}.
+     */
+    readonly resources: OITRenderPassResources;
+    private fullscreenRenderer;
+    private minDepthTarget;
+    private accumTarget;
+    private compositeMaterial;
+    /** Lazily-created material for the debug-target thumbnails. */
+    private debugMaterial;
+    /** Lazily-created GPU timer, only when {@link profile} is first enabled. */
+    private gpuTimer;
+    /**
+     * OIT pipeline registration release handle. Acquired lazily on the first
+     * {@link render} rather than in the constructor: the host (e.g. a `useMemo`) may
+     * construct passes that React then discards without ever committing/rendering them,
+     * and a constructor-time acquire on such an orphan would never be released. Only
+     * committed passes are rendered, so acquiring here keeps the registration count
+     * symmetric with {@link dispose}.
+     */
+    private releaseOit?;
+    private entryCache;
+    /** Monotonic count of classification entries created (cache misses). */
+    private entriesCreated;
+    /** Saved material state for OIT objects temporarily forced opaque this frame. */
+    private forcedOpaque;
+    private width;
+    private height;
+    private depthFar;
+    constructor(scene: Scene, camera: Camera);
+    setSize(width: number, height: number): void;
+    dispose(): void;
+    private getEntry;
+    /**
+     * Traverse the scene once, classifying renderables into transparent-OIT,
+     * plain-opaque, emissive (additive/glow) and always-on-top overlay sets.
+     * OIT-capable objects that are currently fully opaque, or explicitly tagged with
+     * the `LAYERS.FORCE_OPAQUE` layer, are added to both `opaqueList` (for the
+     * visibility lifecycle) and `oitOpaqueList` (so their materials can be forced
+     * depth-writing), making them real occluders. Objects tagged `LAYERS.OIT_EXCLUDED`
+     * are added to `opaqueList` only, so they render with their material untouched.
+     * Emissive objects are detected by the EMISSIVE layer, overlay objects by the
+     * OVERLAY layer.
+     */
+    private collect;
+    /**
+     * Prepare the OIT renderables for the opaque pass. Objects whose whole material
+     * is OIT-capable are simply hidden (and collected into `hidden` for restore), so
+     * their geometry isn't rasterised at all. Mixed multi-material meshes are swapped
+     * to their opaque variant (opaque groups kept, OIT groups drawn as no-op).
+     */
+    private applyOpaqueSwap;
+    private applyPassSwap;
+    private restoreMaterials;
+    private setOitUniforms;
+    private setVisible;
+    /**
+     * Resolve the opt-in depth-stamp material for an emissive emitter, if any. The
+     * emitter exposes it on `material.userData.occlusionDepthMaterial`; this also drives
+     * its `uOcclusionThreshold` uniform from {@link emitterDepthThreshold}. Returns null
+     * when the emitter provides no stamp material (it is then skipped).
+     */
+    private getEmitterStamp;
+    /**
+     * Current effective opacity of a material. `ShaderMaterial`s drive opacity through
+     * a `uniforms.opacity` value (the material's own `opacity` field is often left at
+     * 1), so prefer that; otherwise use `Material.opacity`.
+     */
+    private static effectiveOpacity;
+    /** Whether a material currently renders as fully opaque. */
+    private static isMaterialOpaque;
+    /**
+     * Whether an OIT entry is currently fully opaque (every OIT-capable material is
+     * opaque). Such objects are drawn in the opaque pass as real occluders instead of
+     * being routed through the (more expensive, depth-non-writing) OIT passes.
+     */
+    private isEntryOpaque;
+    /**
+     * Temporarily force the OIT-capable materials of the given entries to write depth
+     * and render opaque, so they act as genuine occluders during the opaque pass. The
+     * previous state is saved and restored by {@link restoreForcedOpaque}. These
+     * objects are hidden during the OIT sub-passes, so the forced state only takes
+     * effect where intended.
+     */
+    private applyForcedOpaque;
+    private restoreForcedOpaque;
+    /**
+     * Copy the latest smoothed GPU timings out of the timer into {@link timings} and
+     * recompute the `total`. Segments without a result yet (or skipped this frame)
+     * report `-1` and are excluded from the total.
+     */
+    private updateTimings;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+    /**
+     * Draw small thumbnails of the auxiliary render targets along the bottom-left of
+     * the output buffer (min-depth, accumulation). Uses the buffer's viewport
+     * to scope each draw; GPU-only.
+     */
+    private renderDebugTargets;
+}

package/dist/types/rendering/passes/OutputPass.d.ts

@@ -0,0 +1,10 @@
+import { MeshBasicMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { FullscreenRenderer } from '../fullscreen-renderer';
+import { Pass } from '../Pass';
+export declare class OutputPass extends Pass {
+    fullscreenRenderer: FullscreenRenderer;
+    material: MeshBasicMaterial;
+    constructor();
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+    dispose(): void;
+}

package/dist/types/rendering/passes/RenderPass.d.ts

@@ -0,0 +1,8 @@
+import { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from '../Pass';
+export declare class RenderPass extends Pass {
+    private scene;
+    private camera;
+    constructor(scene: Scene, camera: Camera);
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+}

package/dist/types/rendering/passes/SMAAPass.d.ts

@@ -0,0 +1,40 @@
+import { Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from '../Pass';
+/**
+ * Subpixel Morphological Anti-Aliasing (SMAA) post-process pass for use with the
+ * {@link RenderingPipeline}. A drop-in alternative to {@link FxaaPass}: it detects
+ * edges by colour discontinuity and reconstructs anti-aliased silhouettes using
+ * precomputed area/search lookup tables, giving noticeably cleaner long edges on
+ * opaque geometry than FXAA, with less detail blurring.
+ *
+ * SMAA operates in linear space and must run before the {@link OutputPass} (i.e.
+ * before tone-mapping / output-encoding), exactly like {@link FxaaPass}.
+ *
+ * Like all morphological techniques it cannot recover sub-pixel features (e.g.
+ * 1px WebGL lines that fall between samples) — use {@link TAAPass} for those.
+ *
+ * This wraps the well-tested SMAA shaders and lookup textures from `three-stdlib`
+ * and drives the three sub-passes (edge detection, blend-weight calculation,
+ * neighbourhood blending) through the pipeline's {@link FullscreenRenderer},
+ * compositing the result back into the shared buffer in place.
+ *
+ * @group Rendering
+ * @see {@link RenderingPipeline}
+ * @see {@link FxaaPass}
+ * @see {@link TAAPass}
+ */
+export declare class SMAAPass extends Pass {
+    private inner;
+    private scratch;
+    private blitMaterial;
+    private fullscreenRenderer;
+    private materialEdges;
+    private materialWeights;
+    private materialBlend;
+    constructor();
+    setSize(width: number, height: number): void;
+    dispose(): void;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+    /** Resolution uniform helper kept for parity with other passes. */
+    get resolution(): Vector2;
+}

package/dist/types/rendering/passes/TAAPass.d.ts

@@ -0,0 +1,94 @@
+import { Camera, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from '../Pass';
+/**
+ * Temporal Anti-Aliasing pass (jittered accumulation) for use with the
+ * {@link RenderingPipeline}.
+ *
+ * Each frame the camera's projection is offset by a sub-pixel jitter from a
+ * Halton(2,3) sequence and the freshly rendered buffer is accumulated into a
+ * history target as a running average. Because the 1px-line problem with
+ * supersampling is that the line stays one device-pixel wide as the buffer
+ * grows, jittered accumulation is the technique that *does* anti-alias thin
+ * features: the same 1px line lands on slightly different sub-pixel positions
+ * each frame, so the average is coverage-weighted without thinning.
+ *
+ * The accumulation resets whenever the (un-jittered) camera view changes, so an
+ * orbit-and-inspect workflow converges to near-supersampled quality within a
+ * handful of static frames. Once the full jitter sequence has accumulated the
+ * pass freezes (no further jitter or blending) and presents the converged image
+ * until the next camera move, so a still camera settles to a stable result.
+ * Place it where you would place {@link FxaaPass} — before the {@link OutputPass}.
+ *
+ * Limitations (no history reprojection / neighbourhood clamping): animated
+ * content that moves while the camera is static (e.g. additive jet streams) does
+ * not update once the image has converged and frozen, and ghosts before then.
+ * Camera motion itself never ghosts because it triggers a reset.
+ *
+ * @todo Improve TAA. Current trade-offs to address: (1) AA is only present once
+ * the camera settles — during motion the image is un-anti-aliased and it takes
+ * roughly a second of stillness to converge; (2) because the pass freezes on
+ * convergence, content that changes while the camera is static (a highlight
+ * toggled on, async geometry finishing loading) does not appear until the next
+ * camera move. A proper fix needs motion vectors + history reprojection +
+ * neighbourhood colour clamping so the history can be reused under motion and
+ * invalidated per-pixel on content change, rather than the all-or-nothing
+ * reset-on-camera-move + freeze-on-convergence heuristic used here. Likely
+ * revisited as part of the WebGPU/TSL renderer migration.
+ *
+ * @group Rendering
+ * @see {@link RenderingPipeline}
+ * @see {@link FxaaPass}
+ * @see {@link SMAAPass}
+ */
+export declare class TAAPass extends Pass {
+    private camera;
+    /**
+     * Number of unique jitter samples to cycle through before the average is
+     * considered fully converged. Higher = smoother but slower to settle.
+     */
+    sampleCount: number;
+    private historyRead;
+    private historyWrite;
+    private resolveMaterial;
+    private blitMaterial;
+    private fullscreenRenderer;
+    private width;
+    private height;
+    /** Index into the jitter sequence for the current frame. */
+    private sampleIndex;
+    /** How many frames have been accumulated since the last reset. */
+    private accumulated;
+    /** Jitter (in clip-space units) currently baked into the camera projection. */
+    private appliedJitterX;
+    private appliedJitterY;
+    /** Snapshot of the previous frame's camera state used to detect motion. The
+     * view matrix and the projection are stored separately so the two projection
+     * elements we jitter can be excluded from the comparison (see `detectMotion`). */
+    private prevView;
+    private prevProjection;
+    private hasPrev;
+    constructor(camera: Camera, sampleCount?: number);
+    setSize(width: number, height: number): void;
+    dispose(): void;
+    /** Force the accumulation to restart on the next frame. */
+    reset(): void;
+    /** Indices into the projection matrix offset elements for the active camera. */
+    private jitterElements;
+    private clearJitter;
+    private applyJitter;
+    /**
+     * Compare the current camera against the previous frame and reset the
+     * accumulation on any real view change (orbit, pan, zoom, fov).
+     *
+     * Motion is measured from the camera's view matrix (`matrixWorldInverse`,
+     * which we never touch) and its projection matrix *excluding* the two elements
+     * we jitter (`ex`/`ey`). This is critical: deriving motion from a quantity that
+     * includes our own sub-pixel jitter — or trying to subtract the jitter back out
+     * of the projection — couples the test to the jitter and makes every frame look
+     * like motion (the jitter delta dwarfs the tolerance), so the accumulation
+     * resets forever and the image never settles. By ignoring the jittered slots
+     * outright, only genuine camera changes trigger a reset.
+     */
+    private detectMotion;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+}

package/dist/types/rendering/passes/index.d.ts

@@ -0,0 +1,6 @@
+export * from './FXAAPass';
+export * from './OITRenderPass';
+export * from './OutputPass';
+export * from './RenderPass';
+export * from './SMAAPass';
+export * from './TAAPass';