@equinor/videx-3d 2.0.0 → 3.0.0

package/dist/types/components/Ocean/ocean-volume-material.d.ts

@@ -0,0 +1,54 @@
+import { Color, ShaderMaterial, ShaderMaterialParameters, Vector4 } from 'three';
+export type OceanVolumeMaterialParameters = ShaderMaterialParameters & {
+    waveCount?: number;
+};
+/**
+ * OIT-compatible water-body (volume) material for the side walls of an ocean
+ * box. Shades the walls as a transparent, depth-tinted blue body (a fog-like
+ * tint that builds up with view distance), so the interior reads as water both
+ * when the camera is inside the box and when looking in from outside. Rendered
+ * double-sided so the walls are visible from either side. Shares the surface's
+ * deep and shallow colours so the body matches the surface.
+ *
+ * The wall's top ring follows the same spectral wave displacement as the ocean
+ * surface (tapered to zero at the sea bed) so the rim stays sealed when vertex
+ * displacement is enabled. Share the surface's wave tables via
+ * {@link OceanVolumeMaterial.setWaveTables} so the walls move in lock-step.
+ *
+ * Wired for the OITRenderPass via {@link attachOitVariants} (variants share this
+ * material's `uniforms` by reference, so animated uniforms stay live).
+ */
+export declare class OceanVolumeMaterial extends ShaderMaterial {
+    isOceanVolumeMaterial: boolean;
+    constructor(parameters?: OceanVolumeMaterialParameters);
+    /**
+     * Point this material's wave-component uniform arrays at the surface
+     * material's tables (by reference) so the displaced wall top ring tracks the
+     * surface waves with no extra per-frame work. The surface mutates those
+     * Vector4s in place when the sea state changes, so the walls update for free.
+     */
+    setWaveTables(waveA: Vector4[], waveB: Vector4[]): void;
+    get time(): number;
+    set time(value: number);
+    /** Gerstner choppiness applied to the displaced top-ring swells. */
+    get steepness(): number;
+    set steepness(value: number);
+    /** Top-ring vertex displacement amount (0 = flat top edge, clamped to [0, 1]). */
+    get displacement(): number;
+    set displacement(value: number);
+    get deepColor(): Color;
+    set deepColor(value: Color | string | number);
+    get shallowColor(): Color;
+    set shallowColor(value: Color | string | number);
+    /** Per-meter tint build-up through the water body. */
+    get fogDensity(): number;
+    set fogDensity(value: number);
+    /** Densest tint reached far through the water (0..1). */
+    get maxOpacity(): number;
+    set maxOpacity(value: number);
+    /** Animated brightness shimmer amount (0 = off). */
+    get shimmer(): number;
+    set shimmer(value: number);
+    get masterOpacity(): number;
+    set masterOpacity(value: number);
+}

package/dist/types/components/Tanker/Tanker.d.ts

@@ -0,0 +1,47 @@
+import { TankerDetails } from './TankerSuperstructure';
+export type TankerProps = {
+    length?: number;
+    width?: number;
+    height?: number;
+    waterline?: number;
+    wireframe?: boolean;
+    lengthSegments?: number;
+    profileSegments?: number;
+    bowLength?: number;
+    bowRoundness?: number;
+    details?: TankerDetails;
+    lowerHullColor?: string;
+    upperHullColor?: string;
+    deckColor?: string;
+    stripeColor?: string;
+    superstructureColor?: string;
+    /**
+     * Float on the waves when rendered inside an `<Ocean>` (heave/pitch/roll
+     * driven by the live wave field). No effect outside an `<Ocean>`. Default
+     * `true`.
+     */
+    buoyancy?: boolean;
+    /**
+     * Displacement in tonnes. Heavier vessels follow the waves more sluggishly
+     * (more inertia); lighter ones bob more readily. Default `120000` (Aframax).
+     */
+    weight?: number;
+    /**
+     * Spread foam where the hull meets the water when rendered inside an
+     * `<Ocean>`. No effect outside an `<Ocean>`. Default `true`.
+     */
+    contactFoam?: boolean;
+    /**
+     * Overall scale of the contact foam (0 = none, 1 = full). The actual amount
+     * also rises with how much the hull is moving (heave/pitch/roll), so it is
+     * stronger in rougher seas and subtle when the vessel sits still. Default `1`.
+     */
+    contactFoamIntensity?: number;
+    /**
+     * How much the contact foam is reduced toward the bow and stern, 0..1. 0 = an
+     * even collar all around the hull; 1 = foam only along the sides. Default
+     * `0.6` (a tanker pushes most water along its long flat sides).
+     */
+    contactFoamEndFalloff?: number;
+};
+export declare const Tanker: ({ length, width, height, waterline, lengthSegments, profileSegments, bowLength, bowRoundness, wireframe, details, lowerHullColor, upperHullColor, deckColor, stripeColor, superstructureColor, buoyancy, weight, contactFoam, contactFoamIntensity, contactFoamEndFalloff, }: TankerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Tanker/TankerSuperstructure.d.ts

@@ -0,0 +1,23 @@
+export type TankerDetails = 'low' | 'medium' | 'high';
+export type TankerSuperstructureProps = {
+    length: number;
+    width: number;
+    height: number;
+    waterline: number;
+    details?: TankerDetails;
+    color?: string;
+    wireframe?: boolean;
+};
+/**
+ * Deck superstructure for the {@link Tanker}: an aft accommodation block with a
+ * bridge and a funnel/chimney (always present), plus extra fittings that scale
+ * in with the `details` level (railings, helideck, masts, antennas, pipe rack).
+ *
+ * All dimensions are derived from the ship's dimensions so the structure scales
+ * with the hull. Parts are built from Three.js primitives and overlap their
+ * supports slightly to stay free of z-fighting.
+ *
+ * Coordinate frame matches the hull: origin at the waterline midship, bow +X,
+ * up +Y, starboard +Z; the top deck sits at y = height - waterline.
+ */
+export declare const TankerSuperstructure: ({ length, width, height, waterline, details, color, wireframe, }: TankerSuperstructureProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Tanker/tanker-geometry-builder.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+interface TankerHullParams {
+    length: number;
+    width: number;
+    height: number;
+    waterline: number;
+    lengthSegments: number;
+    profileSegments: number;
+    bowLength: number;
+    bowRoundness: number;
+}
+/**
+ * Creates a THREE.BufferGeometry for an oil tanker hull
+ * Uses a loft/sweep approach: sweep a cross-section profile along the ship's length
+ * and adding bow and stern sections to close the hull.
+ *
+ * Coordinate frame: origin at the waterline, midship. Bow faces +X, vertical is +Y,
+ * starboard is +Z. Keel sits at y = -waterline, deck at y = height - waterline.
+ */
+export declare function createTankerHull(params?: Partial<TankerHullParams>): THREE.BufferGeometry;
+export {};

package/dist/types/main.d.ts

@@ -9,6 +9,7 @@ export * from './components/Grids';
 export * from './components/Highlighter';
 export * from './components/Html';
 export * from './components/ObservableGroup/ObservableGroup';
+export * from './components/Ocean';
 export * from './components/SDFTest/SDFTest';
 export * from './components/Surfaces';
 export * from './components/Symbol';

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

@@ -1,6 +1,15 @@
-import { WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Color, WebGLRenderer, WebGLRenderTarget } from 'three';
 export declare abstract class Pass {
     writeToScreen: boolean;
+    /**
+     * Explicit background for passes that clear the frame (e.g. {@link RenderPass} and
+     * the OIT opaque clear). When set, the pass clears to this colour/alpha instead of
+     * the renderer's current clear state, giving a single source of truth so the
+     * background is identical regardless of which base pass renders the scene. When
+     * `null` the pass falls back to the renderer's current clear colour/alpha.
+     */
+    clearColor: Color | null;
+    clearAlpha: number;
     setSize?(width: number, height: number, pixelRatio: number): void;
     dispose?(): void;
     abstract render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;

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

@@ -6,7 +6,16 @@ import { Pass } from './Pass';
 export type RenderingPipelineProps = {
     /** Ordered list of passes to execute every frame. */
     passes: Pass[];
-    /** Multisample count for the main render target. Defaults to 0. */
+    /**
+     * Multisample count (MSAA) for the main render target. Defaults to 0.
+     *
+     * This applies hardware MSAA to the pipeline's shared render target and is only
+     * meaningful for an opaque {@link RenderPass}-based pipeline. When the base pass
+     * is an {@link OITRenderPass}, keep this at `0`: OIT renders into its own
+     * multi-target buffers, so pipeline-level MSAA would add cost without
+     * anti-aliasing the resolved result. Use {@link OITRenderPass.opaqueSamples}
+     * instead to multisample the opaque sub-pass inside OIT.
+     */
     samples?: number;
     /** Render target supersampling factor. Defaults to 1. */
     supersample?: number;

package/dist/types/rendering/debug/DebugBoxOutputPass.d.ts

@@ -0,0 +1,22 @@
+import { RawShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { FullscreenRenderer } from '../fullscreen-renderer';
+import { Pass } from '../Pass';
+/**
+ * Alternative output pass that performs an explicit NxN box downsample of the
+ * supersampled buffer straight to the screen. Intended purely as an A/B reference
+ * against the mipmap-based {@link OutputPass}: with the same scene/pattern and
+ * supersample factor, the only difference is the resample filter, which isolates
+ * whether the perceived aliasing comes from the downsample step.
+ *
+ * Tone mapping is not applied here (only sRGB / linear output encode), so pair it
+ * with tone mapping = none for a fair comparison. Story/debug only.
+ */
+export declare class DebugBoxOutputPass extends Pass {
+    fullscreenRenderer: FullscreenRenderer;
+    material: RawShaderMaterial;
+    supersample: number;
+    constructor(supersample?: number);
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+    dispose(): void;
+}

package/dist/types/rendering/debug/DebugPatternPass.d.ts

@@ -0,0 +1,30 @@
+import { RawShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { FullscreenRenderer } from '../fullscreen-renderer';
+import { Pass } from '../Pass';
+/**
+ * Named test signals produced by {@link DebugPatternPass}.
+ * - `zonePlate` / `grid` / `checker`: high-frequency signals for anti-aliasing /
+ *   supersampling / downsample inspection.
+ * - `gradient` / `colorBars` / `grayStep` / `grayCard`: known linear values for
+ *   colour-space and tone-mapping verification.
+ */
+export type DebugPattern = 'zonePlate' | 'grid' | 'checker' | 'gradient' | 'colorBars' | 'grayStep' | 'grayCard';
+/**
+ * Debug pass that overwrites the shared pipeline buffer with a synthetic test
+ * signal (see {@link DebugPattern}). It writes *linear* values at the buffer's
+ * (supersampled) resolution, replacing scene geometry so the rest of the pipeline
+ * — supersample downsample, tone mapping and output colour-space encode — can be
+ * validated against a known input.
+ *
+ * Story/debug only — not part of the public rendering API.
+ */
+export declare class DebugPatternPass extends Pass {
+    fullscreenRenderer: FullscreenRenderer;
+    material: RawShaderMaterial;
+    constructor(pattern?: DebugPattern, scale?: number);
+    set pattern(value: DebugPattern);
+    set scale(value: number);
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+    dispose(): void;
+}

package/dist/types/rendering/fxaa-resolver.d.ts

@@ -0,0 +1,25 @@
+import { WebGLRenderer, WebGLRenderTarget } from 'three';
+/**
+ * Fast Approximate Anti-Aliasing (FXAA) resolver. A single-pass, purely spatial
+ * morphological technique: it estimates edge direction from local luma and blends
+ * along it. Very cheap, but softer than SMAA and — like all spatial techniques —
+ * unable to recover sub-pixel features (thin lines/tubes that fall between
+ * samples); those need supersampling or the temporal mode.
+ *
+ * It operates entirely in the pipeline's linear FP16 space: the shader detects
+ * edges with a cheap perceptual luma but blends the linear texels, so brightness
+ * is untouched, flat regions are an exact passthrough, and HDR values above 1 are
+ * preserved (no LDR clamp). Because the neighbourhood taps cannot read the same
+ * target being written, it resolves into a scratch target and blits the result
+ * back into the buffer in place.
+ */
+export declare class FxaaResolver {
+    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/index.d.ts

@@ -6,3 +6,4 @@ export * from './Pass';
 export * from './passes';
 export * from './rendering-state';
 export * from './RenderingPipeline';
+export type { SMAAQuality } from './smaa-resolver';

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

@@ -26,6 +26,7 @@ export declare class AnnotationsPass extends Pass {
     private occlusionChanged;
     connectorTargetFrameTime: number;
     connectorStretchSlack: number;
+    connectorRestStretch: 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

@@ -1,11 +1,16 @@
 import { WebGLRenderer, WebGLRenderTarget } from 'three';
 import { Pass } from '../Pass';
-export declare class FxaaPass extends Pass {
-    private scratch;
-    private fxaaMaterial;
-    private blitMaterial;
-    private fullscreenRenderer;
-    constructor();
+/**
+ * Standalone FXAA post pass. Wraps a {@link FxaaResolver} and composites it in
+ * place into the shared pipeline buffer, so it works after any base pass
+ * ({@link RenderPass} or {@link OITRenderPass}) — unlike the OIT-internal SMAA /
+ * temporal modes it does not require order-independent transparency.
+ *
+ * Insert it between the base pass and the {@link OutputPass}:
+ * `[base, new FXAAPass(), new OutputPass()]`.
+ */
+export declare class FXAAPass extends Pass {
+    private resolver;
     setSize(width: number, height: number): void;
     dispose(): void;
     render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;

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

@@ -1,5 +1,8 @@
 import { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
 import { Pass } from '../Pass';
+import { SMAAQuality } from '../smaa-resolver';
+import { TaaResolver } from '../taa-resolver';
+import { TemporalResolver } from '../temporal-resolver';
 /** Per-frame object counts for each classification, exposed for debugging. */
 export type OITRenderPassStats = {
     /** Plain opaque renderables (not OIT-capable, not overlay). */
@@ -81,6 +84,14 @@ export type OITRenderPassTimings = {
     /** Sum of the measured OIT segments above. */
     total: number;
 };
+/**
+ * Built-in anti-aliasing mode for {@link OITRenderPass.antialias}. See that field for
+ * the per-mode description. Exported as the single source of truth so consumers
+ * (and Storybook arg types) can reference it instead of re-declaring the union.
+ *
+ * @group Rendering
+ */
+export type OITAntialiasMode = 'none' | 'temporal' | 'smaa' | 'temporal-smaa' | 'taa' | 'fxaa';
 /**
  * Hybrid order-independent-transparency (OIT) render pass for use with the
  * {@link RenderingPipeline} (or any custom composer). Renders the nearest transparent
@@ -122,6 +133,106 @@ export declare class OITRenderPass extends Pass {
      * Useful for isolating tail behaviour and comparing against the hybrid result.
      */
     skipFront: boolean;
+    /**
+     * Number of MSAA samples (0 = off) for the hybrid multisample path. When > 0 the
+     * opaque geometry (including fully-opaque OIT occluders such as casings/completion
+     * tools), the emissive layer, the weighted-blended (WBOIT) tail composite, the exact
+     * front layer and the overlay are all rendered into ONE dedicated multisample target
+     * sharing the pipeline depth. The single-sample min-depth/accum aux targets read the
+     * opaque depth resolved on the first switch away from the multisample target; the
+     * final colour is resolved ONCE more and blitted into the single-sample pipeline
+     * buffer (~2 resolves total). This costs more than multisampling the opaque pass
+     * alone but far less than multisampling the whole half-float pipeline buffer
+     * (~4 resolves). Clamped to `renderer.capabilities.maxSamples`.
+     *
+     * **MSAA is not recommended with OIT.** The min-depth/accum aux buffers must be
+     * single-sample (WebGL2 cannot sample a multisample texture), so the transparent
+     * tail is composited single-sample over the multisample opaque edges. Opaque edges
+     * are matted against the cleared background before the transparent surfaces exist,
+     * and the single-sample composite cannot reconstruct per-sample coverage — so a
+     * background-coloured fringe survives along opaque and thin-line edges *over
+     * transparent surfaces*. This is structural and cannot be made clean here; only
+     * supersampling the whole composite (an {@link antialias} temporal mode, or the
+     * {@link RenderingPipeline} `supersample` prop) removes it.
+     *
+     * `opaqueSamples` is therefore intended only for the narrow **opaque-only** close-up
+     * (no transparent surfaces composited in front — e.g. a casing detail view), where
+     * the fringe cannot occur. For anything with transparent surfaces leave this at `0`
+     * and use {@link antialias} (temporal / SMAA / TAA / FXAA) or the
+     * {@link RenderingPipeline} `supersample` prop instead. (Pipeline-level `samples`
+     * does not anti-alias the OIT result either, and is only for a plain opaque
+     * `RenderPass` pipeline with no OIT.)
+     *
+     * Do not combine `opaqueSamples > 0` with an {@link antialias} temporal mode
+     * (`'temporal'`/`'temporal-smaa'`/`'taa'`): it is wasteful — the multisample colour
+     * is resolved first and the temporal resolver then runs on the already-resolved
+     * buffer, so you pay for MSAA rasterisation on top of temporal supersampling that
+     * already anti-aliases the same edges.
+     */
+    opaqueSamples: number;
+    /**
+     * Built-in anti-aliasing mode for the composited result.
+     *
+     * - `'none'`: no built-in AA. Pair with {@link opaqueSamples} (MSAA) for
+     *   opaque-edge AA in an opaque-only close-up; transparent/additive edges stay
+     *   un-anti-aliased, and MSAA leaves a background-coloured fringe over transparent
+     *   surfaces (see {@link opaqueSamples}).
+     * - `'temporal'`: temporal supersampling (see {@link TemporalResolver}). The camera
+     *   is sub-pixel jittered each frame and the composited frame is accumulated into a
+     *   running average **while the camera is still**, converging to a genuinely
+     *   supersampled image (thin trajectory lines, transparent-surface edges, contour
+     *   lines and the additive highlight all anti-alias). There is no reprojection, so
+     *   nothing ghosts; while the camera moves the current frame is shown un-jittered
+     *   (the moving frame is not anti-aliased unless combined with SMAA or MSAA).
+     * - `'smaa'`: subpixel morphological AA (see {@link smaaQuality}) applied as a
+     *   spatial post pass every frame. Anti-aliases moving frames too, but (like all
+     *   morphological techniques) cannot recover sub-pixel features such as 1px lines
+     *   that fall between samples.
+     * - `'temporal-smaa'`: both, mutually exclusive per frame — temporal accumulation
+     *   while the camera is still (crisp, recovers sub-pixel detail) and SMAA while it
+     *   moves. SMAA never softens the converged still image and only costs GPU time
+     *   during motion.
+     * - `'taa'` (default): reprojected temporal anti-aliasing (see {@link TaaResolver}).
+     *   Like `'temporal'` the camera is sub-pixel jittered, but the history is
+     *   reprojected every frame using the nearest visible surface's depth (opaque
+     *   hardware depth refined by the OIT front-layer depth), so anti-aliasing is
+     *   retained *during* camera motion. Ghosting from additive/animated/disoccluded
+     *   content is bounded by neighbourhood colour clamping. This is the recommended
+     *   default for the OIT pipeline — it anti-aliases both still and moving frames.
+     *   Use `'temporal'` instead if you need guaranteed ghost-free stills and don't
+     *   mind losing motion AA.
+     * - `'fxaa'`: fast approximate AA (see {@link FxaaResolver}) applied as a single
+     *   cheap spatial post pass every frame. Cheaper and softer than `'smaa'`, with no
+     *   OIT or temporal coupling. Like all spatial techniques it cannot recover
+     *   sub-pixel features. Also available as the standalone {@link FXAAPass} for
+     *   non-OIT (plain `RenderPass`) setups.
+     *
+     * The jitter is applied to the shared camera only between this pass's own scene
+     * render and resolve, so it never leaks to later passes (annotations, picking).
+     * This is the OIT pipeline's high-quality AA. Non-OIT setups (plain `RenderPass`)
+     * should use MSAA instead.
+     */
+    antialias: OITAntialiasMode;
+    /**
+     * SMAA quality preset used by the `'smaa'` and `'temporal-smaa'` {@link antialias}
+     * modes (default `'high'`). Ignored by the other modes.
+     */
+    smaaQuality: SMAAQuality;
+    /**
+     * The temporal-supersampling resolver, exposed for debug/tuning (e.g. its
+     * `clampStrength` anti-ghost knob). Non-null only while {@link antialias} is
+     * `'temporal'` / `'temporal-smaa'` and after at least one frame has rendered (it is
+     * created lazily and recreated on a mode switch, resetting to defaults).
+     */
+    get temporalResolver(): TemporalResolver | null;
+    /**
+     * The reprojected-TAA resolver, exposed for debug/tuning (e.g. its
+     * `restClampStrength` / `restBoxGamma` / `restNeighbourhoodRadius` anti-ghost knobs).
+     * Non-null only while {@link antialias} is `'taa'` and after at least one frame has
+     * rendered (it is created lazily and recreated on a mode switch, resetting to
+     * defaults).
+     */
+    get taaResolver(): TaaResolver | null;
     /**
      * Optional feature (default off): after the transparent OIT passes, stamp depth
      * for transparent surfaces wherever their own alpha is at least
@@ -185,9 +296,28 @@ export declare class OITRenderPass extends Pass {
      */
     readonly resources: OITRenderPassResources;
     private fullscreenRenderer;
+    /** Lazily-created temporal-supersampling resolver, used when {@link antialias} is `'temporal'`. */
+    private temporal;
+    /**
+     * Lazily-created reprojected-TAA resolver, used when {@link antialias} is `'taa'`.
+     */
+    private taa;
+    /**
+     * Lazily-created SMAA spatial resolver, used when {@link antialias} is `'smaa'` or
+     * `'temporal-smaa'`.
+     */
+    private smaa;
+    /** Lazily-created FXAA spatial resolver, used when {@link antialias} is `'fxaa'`. */
+    private fxaa;
     private minDepthTarget;
     private accumTarget;
     private compositeMaterial;
+    /** Shared multisample target for the hybrid MSAA path (see {@link opaqueSamples}). */
+    private opaqueTarget;
+    /** Sample count the current opaqueTarget was built with (-1 = none yet). */
+    private opaqueTargetSamples;
+    /** Blit material: copy the resolved multisample colour into the buffer (no blending). */
+    private opaqueBlitMaterial;
     /** Lazily-created material for the debug-target thumbnails. */
     private debugMaterial;
     /** Lazily-created GPU timer, only when {@link profile} is first enabled. */
@@ -210,9 +340,24 @@ export declare class OITRenderPass extends Pass {
     private height;
     private depthFar;
     constructor(scene: Scene, camera: Camera);
+    /**
+     * Create or resize the shared multisample target, sharing the pipeline's depth
+     * texture so resolving writes the AA colour AND the resolved opaque depth the
+     * auxiliary OIT passes read. Recreated when sample count, size or shared depth
+     * texture changes.
+     */
+    private ensureOpaqueTarget;
+    private disposeOpaqueTarget;
     setSize(width: number, height: number): void;
     dispose(): void;
     private getEntry;
+    /**
+     * Whether an OIT entry is currently fully invisible (every OIT-capable material
+     * has opacity ≤ 0). Such objects are hidden from all passes — they contribute
+     * nothing to any render target, so rasterising them (even through the cheap aux
+     * passes) is pure waste.
+     */
+    private isEntryInvisible;
     /**
      * Traverse the scene once, classifying renderables into transparent-OIT,
      * plain-opaque, emissive (additive/glow) and always-on-top overlay sets.
@@ -251,6 +396,8 @@ export declare class OITRenderPass extends Pass {
     private static effectiveOpacity;
     /** Whether a material currently renders as fully opaque. */
     private static isMaterialOpaque;
+    /** Whether a material currently renders as fully invisible (opacity ≤ 0). */
+    private static isMaterialInvisible;
     /**
      * 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

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

@@ -1,6 +1,15 @@
 import { MeshBasicMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
 import { FullscreenRenderer } from '../fullscreen-renderer';
 import { Pass } from '../Pass';
+/**
+ * Terminal pass: composites the pipeline's linear HDR buffer to the screen and
+ * applies tone mapping + sRGB output encoding once, for the whole buffer, via
+ * `renderer.toneMapping` / `toneMappingExposure` (`toneMapped: true` below).
+ *
+ * Because tone mapping is deferred to this single pass, scene materials must render
+ * linear (`toneMapped: false`) or they double-tone-map, and the per-material
+ * `toneMapped = false` opt-out is not honored. See documents/oit-guide.md §7.
+ */
 export declare class OutputPass extends Pass {
     fullscreenRenderer: FullscreenRenderer;
     material: MeshBasicMaterial;

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

@@ -3,6 +3,8 @@ import { Pass } from '../Pass';
 export declare class RenderPass extends Pass {
     private scene;
     private camera;
+    /** Reused scratch for saving the renderer clear colour (no per-frame alloc). */
+    private prevClearColor;
     constructor(scene: Scene, camera: Camera);
     render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
 }

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

@@ -2,5 +2,3 @@ export * from './FXAAPass';
 export * from './OITRenderPass';
 export * from './OutputPass';
 export * from './RenderPass';
-export * from './SMAAPass';
-export * from './TAAPass';

package/dist/types/rendering/smaa-resolver.d.ts

@@ -0,0 +1,58 @@
+import { WebGLRenderer, WebGLRenderTarget } from 'three';
+/**
+ * Quality preset for SMAA. Higher presets lower the edge-detection threshold (so
+ * fainter edges are anti-aliased) and increase the orthogonal search distance (so
+ * longer near-horizontal/vertical edges are reconstructed). The underlying
+ * three-stdlib SMAA shaders do not implement the reference SMAA's diagonal search
+ * and corner rounding, so those are unaffected by the preset.
+ *
+ * @group Rendering
+ */
+export type SMAAQuality = 'low' | 'medium' | 'high' | 'ultra';
+/**
+ * Subpixel Morphological Anti-Aliasing (SMAA) resolver, used internally by
+ * {@link OITRenderPass} when its `antialias` mode is `'smaa'` or `'temporal-smaa'`.
+ * It detects edges by colour discontinuity and reconstructs anti-aliased
+ * silhouettes using precomputed area/search lookup tables, giving clean long edges
+ * with little detail blurring.
+ *
+ * It operates in linear space (the OIT buffer is linear FP16) but detects edges on
+ * an sRGB-encoded copy so the perceptual thresholds behave as intended; the blend
+ * and output stay linear, so brightness is untouched.
+ *
+ * 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 a {@link FullscreenRenderer}, compositing the
+ * result back into the shared buffer in place.
+ *
+ * Like all morphological techniques it cannot recover sub-pixel features (e.g. 1px
+ * WebGL lines that fall between samples) — those are handled by the temporal
+ * supersampling mode while the camera is still.
+ */
+export declare class SmaaResolver {
+    private inner;
+    private scratch;
+    private encoded;
+    private encodeMaterial;
+    private blitMaterial;
+    private fullscreenRenderer;
+    private materialEdges;
+    private materialWeights;
+    private materialBlend;
+    private _quality;
+    /** Reused scratch for saving the renderer clear colour each frame (no per-frame alloc). */
+    private prevClearColor;
+    constructor(quality?: SMAAQuality);
+    /**
+     * Quality preset (default `'high'`). Assigning it rewrites the edge-detection
+     * threshold and orthogonal search-distance shader defines and recompiles the two
+     * affected sub-pass programs. The recompile only happens when the value actually
+     * changes, so reading/writing the same value every frame is free.
+     */
+    get quality(): SMAAQuality;
+    set quality(value: SMAAQuality);
+    private applyQuality;
+    setSize(width: number, height: number): void;
+    dispose(): void;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+}