@equinor/videx-3d 1.1.1 → 3.0.0

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

@@ -0,0 +1,145 @@
+import { Color, ShaderMaterial, ShaderMaterialParameters, Vector2, Vector3 } from 'three';
+export type OceanMaterialParameters = ShaderMaterialParameters & {
+    waveCount?: number;
+    detailOctaves?: number;
+    contactCount?: number;
+};
+/**
+ * An oriented footprint of a floating object resting on the ocean surface, used
+ * to spread contact foam around it. All values are in the ocean's local frame
+ * (sea level = local y 0).
+ */
+export type OceanContact = {
+    /** Footprint centre X (local). */
+    x: number;
+    /** Footprint centre Z (local). */
+    z: number;
+    /** Heading in radians (rotation about +Y). */
+    heading: number;
+    /** Half-extent along the heading (e.g. half the hull length). */
+    halfLength: number;
+    /** Half-extent across the heading (e.g. half the beam). */
+    halfWidth: number;
+    /** Width (m) of the foam band straddling the footprint edge. */
+    foamWidth: number;
+    /**
+     * Foam strength multiplier (0 = none, 1 = full). Contact foam is independent
+     * of the wind-driven `foamAmount`, so this controls how much foam the object
+     * generates. Default `1`.
+     */
+    intensity?: number;
+    /**
+     * How much the foam is reduced toward the bow/stern (the forward axis), 0..1.
+     * 0 = an even collar all around; 1 = foam only along the sides (where a hull
+     * pushes the most water). Default `0`.
+     */
+    endFalloff?: number;
+};
+/**
+ * Stylized, OIT-compatible ocean surface material.
+ *
+ * The wave field is a discrete set of directional components sampled from a
+ * JONSWAP spectrum tuned for the North Sea (gamma = 3.3), driven by a single
+ * physical input: the wind speed (m/s, U10). Peak frequency, wavelength and
+ * significant wave height follow the standard Pierson-Moskowitz/JONSWAP
+ * relations, so the wave sizes and spacing are physically plausible (e.g.
+ * U = 10 m/s gives Hs ~ 2.1 m and a peak wavelength ~ 88 m). The spectrum is
+ * sampled on the CPU whenever the wind changes and uploaded as uniform arrays;
+ * the shaders just sum the components.
+ *
+ * All wave/foam animation is evaluated in world X/Z space so it tiles
+ * seamlessly across patched geometry. The material is wired for the
+ * OITRenderPass via {@link attachOitVariants}; because its OIT variants share
+ * this material's `uniforms` object by reference, animated uniforms (time,
+ * wind, colours) stay live through every transparency pass.
+ */
+export declare class OceanMaterial extends ShaderMaterial {
+    isOceanMaterial: boolean;
+    private _waveCount;
+    private _waveHeightScale;
+    private _directionalSpread;
+    private _contactCount;
+    constructor(parameters?: OceanMaterialParameters);
+    /**
+     * (Re)sample the JONSWAP spectrum into the wave-component uniform arrays from
+     * the current wind speed/direction. Cheap (a few iterations) and only called
+     * when the wind/height inputs change, never per frame.
+     */
+    private updateWaves;
+    get time(): number;
+    set time(value: number);
+    get windDirection(): Vector2;
+    set windDirection(value: Vector2);
+    get windSpeed(): number;
+    set windSpeed(value: number);
+    /** Wave height multiplier applied on top of the spectrum's physical Hs. */
+    get amplitude(): number;
+    set amplitude(value: number);
+    /** Angular spread (radians) of the wave directions around the wind. */
+    get directionalSpread(): number;
+    set directionalSpread(value: number);
+    /** Significant wave height (m) derived from the current wind/height scale. */
+    get significantHeight(): number;
+    get steepness(): number;
+    set steepness(value: number);
+    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);
+    get waterOpacity(): number;
+    set waterOpacity(value: number);
+    /** Strength of the large-scale tonal variation (currents / slicks). */
+    get tonalVariation(): number;
+    set tonalVariation(value: number);
+    /**
+     * Approximate size of the large-scale tonal variation patches, in kilometers.
+     * Larger values give broader, slower-changing current/slick fields; smaller
+     * values break the water up into finer patches.
+     */
+    get tonalScale(): number;
+    set tonalScale(value: number);
+    /**
+     * Crispness of the tonal variation patch boundaries. 0 keeps the soft FBM
+     * gradient; higher values (up to 1) narrow the transition band so the
+     * currents/slicks read as distinct, well-defined regions.
+     */
+    get tonalSharpness(): number;
+    set tonalSharpness(value: number);
+    /** Colour the water drifts toward in the tonal variation (current / algae / pollution tint). */
+    get tonalColor(): Color;
+    set tonalColor(value: Color | string | number);
+    get skyColor(): Color;
+    set skyColor(value: Color | string | number);
+    get horizonColor(): Color;
+    set horizonColor(value: Color | string | number);
+    get reflectionIntensity(): number;
+    set reflectionIntensity(value: number);
+    get sunDirection(): Vector3;
+    set sunDirection(value: Vector3);
+    get sunColor(): Color;
+    set sunColor(value: Color | string | number);
+    get sunShininess(): number;
+    set sunShininess(value: number);
+    get foamColor(): Color;
+    set foamColor(value: Color | string | number);
+    get foamAmount(): number;
+    set foamAmount(value: number);
+    get fresnelPower(): number;
+    set fresnelPower(value: number);
+    get detailScale(): number;
+    set detailScale(value: number);
+    get detailStrength(): number;
+    set detailStrength(value: number);
+    /** Maximum number of contact footprints this material can render at once. */
+    get contactCount(): number;
+    /**
+     * Upload the current set of floating-object contact footprints. Excess
+     * entries beyond {@link contactCount} are ignored. Cheap: it only copies into
+     * the preallocated uniform vectors, so it is safe to call every frame.
+     */
+    setContacts(contacts: OceanContact[]): void;
+    /** Clear all contact footprints (no contact foam). */
+    clearContacts(): void;
+}

package/dist/types/components/Ocean/ocean-sampler.d.ts

@@ -0,0 +1,93 @@
+import { RefObject } from 'react';
+import { Object3D } from 'three';
+import { OceanMaterial } from './ocean-material';
+/**
+ * Read-only sampler for the live ocean surface. Lets non-rendering code (e.g.
+ * floating objects) query the water height at any world X/Z, in sync with the
+ * animated wave field shown on screen.
+ *
+ * The height is summed from the same spectral wave components the shader uses
+ * (`uWaveA`/`uWaveB` + `uTime`, read by reference from the material), so it
+ * always matches the current sea state, wind and animation time. The optional
+ * Gerstner horizontal displacement and the render-time footprint LOD fade are
+ * intentionally ignored — they are visual-only refinements, not needed for a
+ * plausible floating response, and skipping them keeps sampling cheap.
+ *
+ * Coordinates are in the Ocean group's local frame (sea level = local y 0),
+ * which equals world space for the typical flat, unrotated planar ocean.
+ */
+export interface OceanSampler {
+    /** Water surface height (local y) at the given local X/Z. */
+    getHeightAt(x: number, z: number): number;
+    /** Significant wave height (m) of the current sea state. */
+    readonly significantHeight: number;
+}
+/**
+ * Create an {@link OceanSampler} bound to an {@link OceanMaterial}. The sampler
+ * reads the material's wave uniforms by reference, so it reflects sea-state and
+ * time changes without any extra wiring.
+ */
+export declare function createOceanSampler(material: OceanMaterial): OceanSampler;
+/**
+ * Context carrying the current {@link OceanSampler}. An `<Ocean>` provides this
+ * to its children; floating components read it (directly or via
+ * {@link useBuoyancy}) to follow the waves. `null` when the component is not
+ * rendered inside an `<Ocean>` (so consumers can fall back to a static pose).
+ */
+export declare const OceanSamplerContext: import('react').Context<OceanSampler | null>;
+/**
+ * Access the {@link OceanSampler} provided by an enclosing `<Ocean>`, or `null`
+ * when there is none.
+ */
+export declare function useOceanSampler(): OceanSampler | null;
+/** A body-frame sample point `[x, z]` taken at the object's waterline (y 0). */
+export type BuoyancyPoint = [x: number, z: number];
+/**
+ * Options for {@link useBuoyancy}.
+ */
+export type BuoyancyOptions = {
+    /**
+     * Sample points in the object's local X/Z (at its waterline). Required.
+     *
+     * Place them at the true hull extents (e.g. bow / stern / port / starboard):
+     * this is how the object's length and width feed into the motion. Waves
+     * shorter than the span between points decorrelate, so the fitted plane
+     * yields little pitch/roll (a long ship barely reacts to short chop), while
+     * swells longer than the object move it as a whole.
+     */
+    points: BuoyancyPoint[];
+    /** Master switch; when `false` the object is left untouched. Default `true`. */
+    enabled?: boolean;
+    /**
+     * Response rate (per second) of the heave/pitch/roll smoothing. Higher snaps
+     * to the waves faster; lower is more sluggish. Default `3`.
+     */
+    damping?: number;
+    /**
+     * Relative mass / inertia of the object (default `1`). Models how heavy the
+     * object is: the effective response rate is divided by this, so a heavier
+     * object follows the surface more slowly and its motion amplitude shrinks for
+     * fast waves it cannot keep up with. Use a value relative to a "typical"
+     * object of its kind (e.g. `weight / referenceWeight`).
+     */
+    mass?: number;
+};
+/**
+ * Make an object float on the ocean by following the wave field provided by an
+ * enclosing `<Ocean>`. Reusable for any floating component: pass a ref to the
+ * object's group and a few body-frame sample points (e.g. bow / stern / port /
+ * starboard at the waterline).
+ *
+ * Each frame the water height is sampled at those points (accounting for the
+ * object's current heading and X/Z position) and a plane is fitted to them to
+ * drive:
+ *  - heave  → `position.y` (mean surface height),
+ *  - pitch  → `rotation.z` (fore/aft slope),
+ *  - roll   → `rotation.x` (port/starboard slope),
+ * each critically-damped toward its target so the motion stays smooth and
+ * frame-rate independent. The object's heading (`rotation.y`) is left untouched.
+ *
+ * No-op when there is no enclosing `<Ocean>` (the object keeps its static pose).
+ * Allocation-free and only a handful of cheap samples per frame.
+ */
+export declare function useBuoyancy(ref: RefObject<Object3D | null>, options: BuoyancyOptions): void;

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/Surfaces/Surface.d.ts

@@ -28,6 +28,13 @@ export type SurfaceProps = CommonComponentProps & PointerEvents & {
     wireframe?: boolean;
     normalMap?: Texture;
     normalScale?: Vec2;
+    /**
+     * Precompute the surface normals into a compact texture instead of deriving
+     * them per-fragment from the elevation map. This skips the normal recompute
+     * the shader otherwise repeats across the order-independent transparency
+     * passes, at the cost of a little extra texture memory. Defaults to `false`.
+     */
+    precomputeNormals?: boolean;
     debug?: boolean;
 };
 /**
@@ -43,4 +50,4 @@ export type SurfaceProps = CommonComponentProps & PointerEvents & {
  *
  * @group Components
  */
-export declare const Surface: ({ meta, color, colorRamp, rampMin, rampMax, reverseRamp, useColorRamp, showContours, contoursInterval, contoursColorMode, contoursColorModeFactor, contoursThickness, contoursColor, opacity, priority, maxError, doubleSide, wireframe, normalMap, normalScale, name, userData, receiveShadow, castShadow, layers, position, renderOrder, visible, debug, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: SurfaceProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Surface: ({ meta, color, colorRamp, rampMin, rampMax, reverseRamp, useColorRamp, showContours, contoursInterval, contoursColorMode, contoursColorModeFactor, contoursThickness, contoursColor, opacity, priority, maxError, doubleSide, wireframe, normalMap, normalScale, precomputeNormals, name, userData, receiveShadow, castShadow, layers, position, renderOrder, visible, debug, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: SurfaceProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/Surfaces/SurfaceMaterial.d.ts

@@ -20,6 +20,7 @@ export type SurfaceMaterialParameters = ShaderMaterialParameters & MeshLambertMa
     contoursColor?: string | number | Color;
     elevationTexture?: Texture;
     normalTexture?: Texture;
+    usePrecomputedNormals?: boolean;
     debug?: boolean;
 };
 /**
@@ -48,6 +49,8 @@ export declare class SurfaceMaterial extends ShaderMaterial {
     set showContours(value: any);
     get debug(): any;
     set debug(value: any);
+    get usePrecomputedNormals(): any;
+    set usePrecomputedNormals(value: any);
     dispose(): void;
     onBeforeCompile(): void;
 }

package/dist/types/components/Surfaces/surface-defs.d.ts

@@ -4,4 +4,5 @@ export declare const surfaceTextures = "surfaceTextures";
 export type SurfaceGeometryResponse = PackedBufferGeometry;
 export type SurfaceTexturesResponse = {
     elevationImageBuffer: Float32Array;
+    normalImageBuffer?: Uint8Array;
 };

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/generators/surface-generator.d.ts

@@ -1,4 +1,4 @@
 import { SurfaceTexturesResponse } from '../main';
 import { PackedBufferGeometry, ReadonlyStore } from '../sdk';
-export declare function generateSurfaceTexturesData(this: ReadonlyStore, id: string): Promise<SurfaceTexturesResponse | null>;
+export declare function generateSurfaceTexturesData(this: ReadonlyStore, id: string, computeNormals?: boolean): Promise<SurfaceTexturesResponse | null>;
 export declare function generateSurfaceGeometry(this: ReadonlyStore, id: string, maxError?: number): Promise<PackedBufferGeometry | null>;

package/dist/types/layers/layers.d.ts

@@ -1,5 +1,9 @@
 import { Layers } from 'three';
 export declare const LAYERS: {
+    OIT_EXCLUDED: number;
+    FORCE_OPAQUE: number;
+    OVERLAY: number;
+    EMISSIVE: number;
     NOT_EMITTER: number;
     EMITTER: number;
 };

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/OitMaterial.d.ts

@@ -0,0 +1,59 @@
+import { Side } from 'three';
+/**
+ * Props for {@link OitMaterial}.
+ * @expand
+ */
+export type OitMaterialProps = {
+    /**
+     * Force a specific `side` on the OIT variants (e.g. `DoubleSide`). Defaults to
+     * the material's own side.
+     */
+    side?: Side;
+    /**
+     * Names of custom uniform-container properties on the material to share by
+     * reference with the per-pass variants. Only needed for non-`ShaderMaterial`
+     * materials that read a custom uniforms object in `onBeforeCompile`.
+     */
+    shareUniforms?: string[];
+    /**
+     * Names of value properties (e.g. `color`, `metalness`) to keep live on the
+     * per-pass variants of a cloned built-in material. See
+     * {@link OitMaterialOptions.syncProperties}. Ignored for `ShaderMaterial`s
+     * (already live via shared uniforms).
+     */
+    syncProperties?: string[];
+    /**
+     * - `inject` (default): patch the material's shaders at compile time (stock or
+     *   inline materials whose shader does not already include `oit.glsl`).
+     * - `attach`: the material's shader already `#include`s `oit.glsl` and calls
+     *   `oitProcess` (library materials); only wire up the variant machinery.
+     */
+    mode?: 'inject' | 'attach';
+};
+/**
+ * A declarative helper that makes the material of its parent `mesh` participate in
+ * the {@link OITRenderPass} pipeline, so transparent inline materials are resolved
+ * order-independently instead of being treated as opaque occluders.
+ *
+ * Drop it in as a sibling of the material, inside the `mesh`:
+ *
+ * ```tsx
+ * <mesh geometry={geometry}>
+ *   <shaderMaterial
+ *     uniforms={uniforms}
+ *     vertexShader={vertexShader}
+ *     fragmentShader={fragmentShader}
+ *     transparent
+ *   />
+ *   <OitMaterial side={DoubleSide} />
+ * </mesh>
+ * ```
+ *
+ * It renders an invisible, empty `object3D` purely to locate the parent mesh; the
+ * wiring is idempotent and a no-op outside the OIT pipeline.
+ *
+ * @group Rendering
+ * @see {@link makeOitCompatible}
+ * @see {@link attachOitVariants}
+ */
+export declare function OitMaterial({ side, shareUniforms, syncProperties, mode, }: OitMaterialProps): import("react/jsx-runtime").JSX.Element;

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

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

@@ -0,0 +1,46 @@
+import { Pass } from './Pass';
+/**
+ * Props for the {@link RenderingPipeline} component.
+ * @expand
+ */
+export type RenderingPipelineProps = {
+    /** Ordered list of passes to execute every frame. */
+    passes: Pass[];
+    /**
+     * 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;
+    /** Frame priority (passed to `useFrame`). Defaults to 1. */
+    priority?: number;
+};
+/**
+ * Generic render pipeline component that runs an ordered list of {@link Pass} objects
+ * against a shared `WebGLRenderTarget` (color + depth texture). Use it to compose
+ * custom rendering pipelines — e.g. a {@link OITRenderPass} based pipeline for
+ * order-independent transparency.
+ *
+ * @example
+ * ```tsx
+ * const passes = useMemo(
+ *   () => [new OITRenderPass(scene, camera), new OutputPass()],
+ *   [scene, camera],
+ * );
+ * return <RenderingPipeline passes={passes} />;
+ * ```
+ *
+ * @group Components
+ * @category Rendering
+ * @see {@link Pass}
+ * @see {@link OITRenderPass}
+ * @see {@link OutputPass}
+ */
+export declare const RenderingPipeline: ({ passes, samples, supersample, priority, }: RenderingPipelineProps) => null;

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/fullscreen-renderer.d.ts

@@ -4,6 +4,7 @@ export declare class FullscreenRenderer {
     mesh: Mesh;
     copyMaterial: RawShaderMaterial;
     constructor();
+    dispose(): void;
     renderMaterial(renderer: WebGLRenderer, buffer: WebGLRenderTarget | null, material: Material): void;
     renderTexture(renderer: WebGLRenderer, buffer: WebGLRenderTarget | null, texture: Texture, opacity?: number): void;
 }