@equinor/videx-3d 2.0.0 → 3.1.0

package/dist/types/components/Wellbores/Casings/CasingSection.d.ts

@@ -1,4 +1,5 @@
 import { PointerEvents } from '../../../main';
+import { CasingEffects } from './CasingMaterial';
 import { CasingSectionMaterialOptions } from './Casings';
 import { CasingSectionType } from './casings-defs';
 type CasingSectionProps = {
@@ -11,6 +12,10 @@ type CasingSectionProps = {
     autoSlicePosition?: boolean;
     opacity?: number;
     renderOrder?: number;
+    effects?: CasingEffects;
+    wellLength?: number;
+    sectionIndex?: number;
+    schematic?: boolean;
 } & PointerEvents;
-export declare const CasingSection: ({ section, materialOptions, radialSegments, sizeMultiplier, sliceAngle, sliceOffset, autoSlicePosition, opacity, renderOrder, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: CasingSectionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CasingSection: ({ section, materialOptions, radialSegments, sizeMultiplier, sliceAngle, sliceOffset, autoSlicePosition, opacity, renderOrder, effects, wellLength, sectionIndex, schematic, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: CasingSectionProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/Wellbores/Casings/Casings.d.ts

@@ -1,16 +1,17 @@
 import { ReactElement } from 'react';
-import { Group, MeshStandardMaterialParameters, Object3D } from 'three';
+import { Group, Object3D } from 'three';
 import { CommonComponentProps } from '../../../common/types';
 import { PointerEvents } from '../../../main';
+import { CasingEffects, CasingMaterialParameters } from './CasingMaterial';
 import { CasingSectionType } from './casings-defs';
 /**
  * CasingSectionMaterialOptions
  * @expand
  */
 export type CasingSectionMaterialOptions = {
-    primary: MeshStandardMaterialParameters;
-    inner?: MeshStandardMaterialParameters;
-    slice?: MeshStandardMaterialParameters;
+    primary: CasingMaterialParameters;
+    inner?: CasingMaterialParameters;
+    slice?: CasingMaterialParameters;
 };
 /**
  * MaterialOptions
@@ -31,9 +32,29 @@ export type CasingProps = PointerEvents & CommonComponentProps & {
     shoeFactor?: number;
     overrideSegmentsPerMeter?: number;
     overrideSimplificationThreshold?: number;
+    /** Schematic (diagram) mode: an unlit, flat-shaded look for a clean "cutaway
+     * schematic" rather than realism. Locks the slice to a half-cut that always faces
+     * the camera (`sliceAngle = PI`, `autoSlicePosition = true`, `sliceOffset = 0` -
+     * those props are ignored), renders each face with only its flat `color` (all
+     * lighting/env, textures and realism detail are ignored) plus the `silhouette`
+     * outline for contrast. Dropping the specular lighting also removes the dominant
+     * source of casing aliasing; note that geometric silhouette-edge anti-aliasing still
+     * relies on the host render pipeline (MSAA/FXAA/SMAA). Default false. */
+    schematic?: boolean;
+    /** Maps each section to its material parameters. Keep this a STABLE reference
+     * (module-level function or `useCallback`) - a new function identity each render
+     * rebuilds every section's materials and forces a shader recompile per frame,
+     * which is the main cause of sluggish casing updates. Defaults to a stable
+     * module-level function. */
     materialOptions?: MaterialOptions;
     opacity?: number;
     priority?: number;
+    /** Grouped casing stylization effects (silhouette outline, section edge shading,
+     * procedural weathering, per-section variation and micro-normal surface detail).
+     * Applied as the global default for every section; a section's per-face
+     * `materialOptions.*.effects` override individual sub-effects on top of this.
+     * Defaults to {@link defaultCasingEffects}. */
+    effects?: CasingEffects;
 };
 /**
  * Generic render of casings based on depths, diameters and type. Must be a child of the `Wellbore` component.
@@ -66,7 +87,27 @@ export declare const Casings: import('react').ForwardRefExoticComponent<PointerE
     shoeFactor?: number;
     overrideSegmentsPerMeter?: number;
     overrideSimplificationThreshold?: number;
+    /** Schematic (diagram) mode: an unlit, flat-shaded look for a clean "cutaway
+     * schematic" rather than realism. Locks the slice to a half-cut that always faces
+     * the camera (`sliceAngle = PI`, `autoSlicePosition = true`, `sliceOffset = 0` -
+     * those props are ignored), renders each face with only its flat `color` (all
+     * lighting/env, textures and realism detail are ignored) plus the `silhouette`
+     * outline for contrast. Dropping the specular lighting also removes the dominant
+     * source of casing aliasing; note that geometric silhouette-edge anti-aliasing still
+     * relies on the host render pipeline (MSAA/FXAA/SMAA). Default false. */
+    schematic?: boolean;
+    /** Maps each section to its material parameters. Keep this a STABLE reference
+     * (module-level function or `useCallback`) - a new function identity each render
+     * rebuilds every section's materials and forces a shader recompile per frame,
+     * which is the main cause of sluggish casing updates. Defaults to a stable
+     * module-level function. */
     materialOptions?: MaterialOptions;
     opacity?: number;
     priority?: number;
+    /** Grouped casing stylization effects (silhouette outline, section edge shading,
+     * procedural weathering, per-section variation and micro-normal surface detail).
+     * Applied as the global default for every section; a section's per-face
+     * `materialOptions.*.effects` override individual sub-effects on top of this.
+     * Defaults to {@link defaultCasingEffects}. */
+    effects?: CasingEffects;
 } & import('react').RefAttributes<Group<import('three').Object3DEventMap>>>;

package/dist/types/components/Wellbores/Casings/casings-defs.d.ts

@@ -1,4 +1,6 @@
+import { Color } from 'three';
 import { Vec3 } from '../../../sdk';
+import { CasingEffects } from './CasingMaterial';
 export declare const casings = "casings";
 export type CasingSectionType = {
     type: string;
@@ -15,3 +17,45 @@ export type CasingSectionType = {
     };
 };
 export type CasingsGeneratorResponse = CasingSectionType[];
+/**
+ * The component-level default {@link CasingEffects} applied globally to every section
+ * (a section's per-face `materialOptions.*.effects` can override individual sub-effects
+ * on top of this). Tuned to help adjacent/nested strings read apart.
+ */
+export declare const defaultCasingEffects: CasingEffects;
+/**
+ * A custom function may be passed to the component, but this is not well documented at this time
+ * as this behavior is subject to change.
+ */
+export declare const defaultMaterialOptions: (section: CasingSectionType) => {
+    primary: {
+        color: string;
+        roughness: number;
+        metalness: number;
+        effects: {
+            weathering: {
+                resistance: number;
+            };
+        };
+    };
+    inner: {
+        color: string;
+        roughness: number;
+        metalness: number;
+    };
+    slice: {
+        color: Color;
+        roughness: number;
+        metalness: number;
+        effects: {
+            weathering: {
+                resistance: number;
+            };
+        };
+    } | {
+        color: Color;
+        roughness: number;
+        metalness: number;
+        effects?: undefined;
+    };
+};

package/dist/types/components/Wellbores/Casings/index.d.ts

@@ -1,5 +1,6 @@
+export * from './CasingMaterial';
 export * from './Casings';
 export * from './casings-defs';
+export * from './CasingAnnotations/casing-annotations-defs';
 export * from './CasingAnnotations/CasingAnnotations';
 export * from './CasingAnnotations/CasingLabel';
-export * from './CasingAnnotations/casing-annotations-defs';

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;
+}