@equinor/videx-3d 2.0.0 → 3.1.0

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

@@ -1,40 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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;
-}