@equinor/videx-3d 1.1.1 → 3.0.0

package/dist/src/sdk/materials/shaderLib/oit.glsl

@@ -0,0 +1,106 @@
+// Order-independent transparency (OIT) shared shader chunk.
+//
+// Provides the uniforms and the per-pass output logic used by the OITRenderPass
+// hybrid pipeline (exact depth-peeled front layer + weighted-blended OIT tail).
+//
+// Usage (library ShaderMaterials, GLSL1 / gl_FragColor):
+//   #include <this file>           // brings uniforms + oitProcess()
+//   ...
+//   gl_FragColor = ...;            // compute final straight (non-premultiplied) color
+//   #ifdef USE_OIT
+//     gl_FragColor = oitProcess(gl_FragColor);
+//   #endif
+//
+// The fragment shader must have `vViewPosition` (view-space position) available.
+//
+// Pass selection is driven by defines set on the per-pass variant materials:
+//   USE_OIT            enables the whole block
+//   OIT_DEPTH_PASS     min-depth pre-pass (writes linear view-space depth)
+//   OIT_FRONT_PASS     exact front layer (alpha-over, discards tail fragments)
+//   (none of the above, USE_OIT only) => single-buffer weighted-blended OIT tail
+//
+// The WBOIT tail uses a single RGBA16F accumulation target with optical-depth
+// weighting: each fragment contributes weight b = -ln(1 - alpha), so
+//   accum.rgb = sum(rgb * b),  accum.a = sum(b).
+// The composite recovers the weighted-average colour as accum.rgb / accum.a and the
+// coverage as 1 - exp(-accum.a) = 1 - prod(1 - alpha) -- identical to a separate
+// (ZERO, ONE_MINUS_SRC_COLOR) reveal pass, but without the extra rasterisation.
+//
+// The `oitSkipFront` uniform (1) disables front peeling so the tail pass keeps the
+// front fragments too (debug: everything resolved through WBOIT).
+
+#ifdef USE_OIT
+
+uniform float oitDepthFar;          // normalisation factor for view-space depth
+uniform vec2 oitScreenSize;         // render target size in pixels
+uniform sampler2D oitMinDepthTexture; // per-pixel min linear depth (front layer)
+uniform int oitSkipFront;           // 1 = disable front peeling (debug: all WBOIT)
+uniform float oitOcclusionThreshold; // occlusion-stamp pass: min alpha to write depth
+
+// Process the straight (non-premultiplied) fragment color for the active pass.
+vec4 oitProcess(vec4 color) {
+  #ifdef OIT_OCCLUSION_PASS
+  // Occlusion depth stamp: write depth only where this surface is opaque enough
+  // (its own alpha clears the threshold). Colour writes are disabled on the
+  // variant, so the returned colour is ignored; discarding skips the depth write.
+  // Lets sufficiently-opaque transparent surfaces occlude annotation labels even
+  // though they don't write depth in the regular OIT passes.
+  if(color.a < oitOcclusionThreshold)
+    discard;
+  return color;
+  #endif
+
+  // View-space linear depth, normalised. Independent of the (logarithmic) depth
+  // buffer encoding, so the partition is correct at any camera scale.
+  float linZ = abs(vViewPosition.z) / oitDepthFar;
+
+  #ifdef OIT_DEPTH_PASS
+
+  // Written into an R32F target with MinEquation blending => per-pixel minimum.
+  return vec4(linZ, 0.0, 0.0, 1.0);
+
+  #else
+
+  // Gradient-relative tolerance: only the surface that produced the per-pixel
+  // minimum qualifies as "front". A fixed epsilon would form a depth slab and let
+  // distinct surfaces grazing within it bleed into each other.
+  vec2 uv = gl_FragCoord.xy / oitScreenSize;
+  float minZ = texture2D(oitMinDepthTexture, uv).r;
+  // Depth-relative tolerance. The min-depth pre-pass and this pass rasterise the
+  // SAME geometry with the SAME vertex transform, so the genuine front fragment's
+  // linZ matches the stored minZ to near bit-exactness; a tiny epsilon suffices.
+  // Avoid fwidth(linZ) here: at self-overlap silhouettes the 2x2 derivative quads
+  // straddle the depth discontinuity between layers, so fwidth spikes and inflates
+  // the tolerance, misclassifying back-layer fragments as front (visible edges).
+  float tol = minZ * 1e-3 + 1e-6;
+  bool isFront = (linZ - minZ) <= tol;
+
+  #ifdef OIT_FRONT_PASS
+
+  // Exact front layer: keep only the nearest fragment, blended alpha-over.
+  if(!isFront)
+    discard;
+  return color;
+
+  #else
+
+  // Tail pass: exclude the front fragment (handled exactly by the front pass),
+  // unless front peeling is disabled (debug: every fragment goes through WBOIT).
+  if(isFront && oitSkipFront == 0)
+    discard;
+
+  float alpha = color.a;
+
+  // Optical-depth weight b = -ln(1 - alpha). Additive (ONE, ONE) blending then gives
+  // accum.rgb = sum(rgb * b), accum.a = sum(b). The composite reconstructs both the
+  // weighted-average colour (accum.rgb / accum.a) and the coverage
+  // (1 - exp(-accum.a) = 1 - prod(1 - alpha)) from this single buffer, so no separate
+  // reveal pass is needed. alpha is clamped below 1 to keep b finite.
+  float b = -log(1.0 - clamp(alpha, 0.0, 0.9999));
+  return vec4(color.rgb * b, b);
+
+  #endif // OIT_FRONT_PASS
+  #endif // OIT_DEPTH_PASS
+}
+
+#endif // USE_OIT

package/dist/types/components/Annotations/AutoUpdate.d.ts

@@ -1,3 +1,3 @@
 export declare const AutoUpdate: ({ maxVisible }: {
     maxVisible: number;
-}) => null;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annotations/index.d.ts

@@ -1,8 +1,8 @@
 import { Vec3 } from '../../sdk';
 import { AnnotationProps } from './types';
+export * from '../../rendering/passes/AnnotationsPass';
 export * from './Annotations';
-export * from './annotations-renderer';
 export * from './annotations-state';
 export * from './AnnotationsLayer';
 export * from './types';
-export declare const getAnnotationPosition: (annotation: AnnotationProps) => Vec3;
+export declare const getAnnotationPosition: (annotation: AnnotationProps, target?: Vec3) => Vec3;

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

@@ -55,7 +55,7 @@ export type AnnotationInstanceState = {
     kill?: boolean;
     cooldown?: number;
     opacity?: number;
-    labelWidht: number;
+    labelWidth: number;
     labelHeight: number;
     labelX?: number;
     labelY?: number;
@@ -68,6 +68,8 @@ export type AnnotationInstanceState = {
     _zIndex?: string;
     _transform?: string;
     _needsUpdate?: boolean;
+    _connPrevX?: number;
+    _connPrevY?: number;
 };
 export type AnnotationInstance = {
     id: string;

package/dist/types/components/Annotations/update-annotations.d.ts

@@ -1,6 +1,16 @@
 import { Clock, PerspectiveCamera } from 'three';
 import { Vec2 } from '../../sdk';
 import { AnnotationInstance } from './types';
+/**
+ * Activity flags updated by preprocessInstances each frame. Used by
+ * AnnotationsPass to skip the expensive post-process/overlay work when the
+ * scene is settled (camera static and no animations in progress).
+ */
+export declare const annotationsActivity: {
+    animating: boolean;
+    positionChanged: boolean;
+    deltaTime: number;
+};
 /**
  * PRE-PROCESS INSTANCES
  */

package/dist/types/components/EventEmitter/picking-helper.d.ts

@@ -19,10 +19,26 @@ export declare class PickingHelper {
     private _radius;
     private _pbo;
     private _buffer;
+    private _prevClearColor;
     private _material;
+    /**
+     * Dedicated camera used for the picking render so the shared scene camera is
+     * never mutated. `setViewOffset` rebuilds a camera's projection (it remaps the
+     * frustum to the tiny patch under the cursor), and that mutation would clobber
+     * any external modification of the real camera's projection — e.g. the
+     * sub-pixel jitter a TAA pass bakes in. Each pick this camera is `copy()`d from
+     * the real camera (which faithfully mirrors `matrixWorld`,
+     * `matrixWorldInverse`, the projection and all intrinsics) and the view offset
+     * is applied here instead. `matrixWorldAutoUpdate` is disabled so the renderer
+     * uses the copied world matrix verbatim rather than recomputing it.
+     */
+    private _camera;
     private _listeners;
     private _emitters;
-    private _currentObjectMap;
+    private _mapStarts;
+    private _mapObjectIds;
+    private _objectMapLength;
+    private _objectMapCount;
     constructor(options?: {});
     private traverseObject;
     updateListeners: () => void;
@@ -30,6 +46,12 @@ export declare class PickingHelper {
     getListener: (id: number) => Listener | undefined;
     removeListener: (id: number) => void;
     render(pointer: Vector2, renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera): Promise<PickResult>;
+    /**
+     * Locate the emitter owning a flat id via binary search. Emitter ranges are
+     * contiguous and sorted by start, so the owner is the rightmost entry whose
+     * start is `<= flatId`.
+     */
+    private findEmitterIndex;
     private pick;
     dispose(): void;
 }

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

@@ -0,0 +1,333 @@
+import { ReactNode } from 'react';
+import { BufferGeometry, Group } from 'three';
+import { CommonComponentProps, CustomMaterialProps } from '../../common/types';
+import { Vec2, Vec3 } from '../../sdk/types/common';
+/**
+ * Ocean props
+ * @expand
+ */
+export type OceanProps = CommonComponentProps & CustomMaterialProps & {
+    /**
+     * Geometry to render as the ocean surface. Typically a large plane lying in
+     * the world X/Z plane at sea level (e.g. `createOceanBox(...).surface`). All
+     * wave/foam animation is evaluated in world coordinates, so tiled/patched
+     * geometry aligns seamlessly.
+     */
+    geometry: BufferGeometry;
+    /**
+     * Optional water-body (side walls) geometry, e.g.
+     * `createOceanBox(...).body`. When provided, it is rendered as a separate,
+     * double-sided, transparent-blue volume mesh so the water reads as a body.
+     */
+    bodyGeometry?: BufferGeometry;
+    /**
+     * Optional sea-bed geometry, e.g. `createOceanBox(...).bed`. When provided,
+     * it is rendered as a separate sun-shaded mesh below the surface.
+     */
+    bedGeometry?: BufferGeometry;
+    /** Wind direction in world X/Z (drives wave + foam direction). */
+    windDirection?: Vec2;
+    /**
+     * Wind speed in m/s (U10). Primary driver of the sea state: wave height,
+     * wavelength and foam all follow North-Sea JONSWAP/Pierson-Moskowitz
+     * relations (e.g. ~10 m/s ⇒ Hs ~ 2.1 m, peak wavelength ~ 88 m).
+     */
+    windSpeed?: number;
+    /** Wave height multiplier on top of the spectrum's physical Hs. */
+    amplitude?: number;
+    /** Angular spread (radians) of the wave directions around the wind. */
+    directionalSpread?: number;
+    /** Apparent surface choppiness (normal exaggeration / Gerstner sharpness). */
+    steepness?: number;
+    /**
+     * Enables vertex displacement (`false` = off / flat, per-pixel normals
+     * only). Off by default; at oilfield scale real displacement is
+     * imperceptible except very close to the surface, where only the longest
+     * swells displace. Mainly useful to let floating objects follow the surface
+     * height.
+     */
+    displacement?: boolean;
+    /** Number of summed spectral wave components (compile-time). */
+    waveCount?: number;
+    /** Number of FBM micro-ripple octaves (compile-time). */
+    detailOctaves?: number;
+    /** Deep water colour (seen looking straight down). */
+    deepColor?: string;
+    /** Shallow/scatter water colour (seen at grazing angles). */
+    shallowColor?: string;
+    /** Base body opacity looking straight down (0 = clear, 1 = opaque). */
+    waterOpacity?: number;
+    /** Strength of the large-scale tonal variation (currents / slicks), 0 = off. */
+    tonalVariation?: number;
+    /** Approximate size of the tonal variation patches, in kilometers. */
+    tonalScale?: number;
+    /** Crispness of the tonal variation patch edges (0 = soft, 1 = hard). */
+    tonalSharpness?: number;
+    /** Colour the water drifts toward in the tonal variation (current / algae / pollution tint). */
+    tonalColor?: string;
+    /** Zenith sky colour used for the procedural reflection. */
+    skyColor?: string;
+    /** Horizon sky colour used for the procedural reflection. */
+    horizonColor?: string;
+    /** Reflection intensity multiplier. */
+    reflectionIntensity?: number;
+    /** Sun direction in world space (specular highlight + reflected glow). */
+    sunDirection?: Vec3;
+    /** Sun colour. */
+    sunColor?: string;
+    /** Sun specular shininess exponent. */
+    sunShininess?: number;
+    /** Foam colour. */
+    foamColor?: string;
+    /** Foam amount, 0 = none. */
+    foamAmount?: number;
+    /** Fresnel exponent (higher = reflections concentrated near the horizon). */
+    fresnelPower?: number;
+    /** Micro-ripple frequency (waves per world unit) for close-up detail. */
+    detailScale?: number;
+    /** Micro-ripple normal strength. */
+    detailStrength?: number;
+    /**
+     * Sea-bed base (sandy/yellowish) colour. Only used when `bedGeometry` is
+     * provided. Default `#b8a06a`.
+     */
+    seaBedColor?: string;
+    /**
+     * Strength of the water-colour tint applied to the water-facing (top) side
+     * of the sea bed (0..1). Only used when `bedGeometry` is provided.
+     */
+    seaBedWaterTint?: number;
+    /**
+     * Sea-bed opacity (0..1). Only used when `bedGeometry` is provided. The sea
+     * bed is OIT-routed, so values below 1 let the subsurface geometry below it
+     * show through; 1 (default) makes it a solid occluder.
+     */
+    seaBedOpacity?: number;
+    /**
+     * Sea-bed sand-dune relief strength (0 = off). Only used when `bedGeometry`
+     * is provided. Perturbs the bed's shading normal by a procedural,
+     * footprint-anti-aliased dune height field, adding a subtle sense of depth
+     * and scale that resolves up close and fades to flat far out. Default 0.15.
+     */
+    seaBedDuneStrength?: number;
+    /**
+     * Base sand-dune crest spacing in meters. Only used when `bedGeometry` is
+     * provided. Default 180.
+     */
+    seaBedDuneWavelength?: number;
+    /**
+     * Sand-dune ridge direction in world X/Z. Only used when `bedGeometry` is
+     * provided. Default `[1, 0.6]`.
+     */
+    seaBedDuneDirection?: Vec2;
+    /**
+     * Extra sand-dune crest/trough albedo banding (0 = off). Only used when
+     * `bedGeometry` is provided. Lightens the dune crests and darkens the
+     * troughs on top of the relief shading for a stronger depth cue; fades out
+     * far away like the rest of the dune detail. Default 0.
+     */
+    seaBedDuneSharpness?: number;
+    /**
+     * Per-meter tint build-up of the water body. Only used when `bodyGeometry`
+     * is provided.
+     */
+    bodyFogDensity?: number;
+    /** Densest water-body tint reached far through the water (0..1). */
+    bodyMaxOpacity?: number;
+    /** Animated shimmer amount of the water body, 0 = off. */
+    bodyShimmer?: number;
+    /** Master opacity multiplier (also drives OIT routing). */
+    opacity?: number;
+    /** Toggles visibility of the water-surface mesh. Default `true`. */
+    surfaceVisible?: boolean;
+    /**
+     * Toggles visibility of the water-body (side walls) mesh. Only has an effect
+     * when `bodyGeometry` is provided. Default `true`.
+     */
+    bodyVisible?: boolean;
+    /**
+     * Toggles visibility of the sea-bed mesh. Only has an effect when
+     * `bedGeometry` is provided. Default `true`.
+     */
+    bedVisible?: boolean;
+    /** Debug: render all ocean materials (surface, body, sea bed) as wireframe. */
+    wireframe?: boolean;
+    /**
+     * Children rendered inside the ocean's group, in its local frame. They
+     * receive an {@link OceanSampler} via context (see `useOceanSampler` /
+     * `useBuoyancy`) so floating objects (e.g. a vessel) can follow the waves.
+     */
+    children?: ReactNode;
+};
+/**
+ * Stylized animated ocean surface.
+ *
+ * Renders the provided geometry as a procedurally animated, OIT-compatible
+ * water surface. The wave field is sampled from a North-Sea JONSWAP spectrum
+ * driven by the wind speed (m/s); the visible waves are reconstructed per-pixel
+ * as surface normals (plus a fine micro-ripple layer up close), all evaluated
+ * in world X/Z space so the pattern is continuous across tiled patches with no
+ * repeating texture assets. Level-of-detail uses per-wave footprint
+ * anti-aliasing, so there is no visible LOD ring. Transparency is Fresnel-driven
+ * (see-through looking down, reflective at grazing angles) and composites
+ * correctly with the other transparent subsurface geometry through the
+ * OITRenderPass.
+ *
+ * @example
+ * <Ocean geometry={planeGeometry} windDirection={[1, 0.3]} windSpeed={10} />
+ *
+ * @group Components
+ */
+export declare const Ocean: import('react').ForwardRefExoticComponent<CommonComponentProps & CustomMaterialProps & {
+    /**
+     * Geometry to render as the ocean surface. Typically a large plane lying in
+     * the world X/Z plane at sea level (e.g. `createOceanBox(...).surface`). All
+     * wave/foam animation is evaluated in world coordinates, so tiled/patched
+     * geometry aligns seamlessly.
+     */
+    geometry: BufferGeometry;
+    /**
+     * Optional water-body (side walls) geometry, e.g.
+     * `createOceanBox(...).body`. When provided, it is rendered as a separate,
+     * double-sided, transparent-blue volume mesh so the water reads as a body.
+     */
+    bodyGeometry?: BufferGeometry;
+    /**
+     * Optional sea-bed geometry, e.g. `createOceanBox(...).bed`. When provided,
+     * it is rendered as a separate sun-shaded mesh below the surface.
+     */
+    bedGeometry?: BufferGeometry;
+    /** Wind direction in world X/Z (drives wave + foam direction). */
+    windDirection?: Vec2;
+    /**
+     * Wind speed in m/s (U10). Primary driver of the sea state: wave height,
+     * wavelength and foam all follow North-Sea JONSWAP/Pierson-Moskowitz
+     * relations (e.g. ~10 m/s ⇒ Hs ~ 2.1 m, peak wavelength ~ 88 m).
+     */
+    windSpeed?: number;
+    /** Wave height multiplier on top of the spectrum's physical Hs. */
+    amplitude?: number;
+    /** Angular spread (radians) of the wave directions around the wind. */
+    directionalSpread?: number;
+    /** Apparent surface choppiness (normal exaggeration / Gerstner sharpness). */
+    steepness?: number;
+    /**
+     * Enables vertex displacement (`false` = off / flat, per-pixel normals
+     * only). Off by default; at oilfield scale real displacement is
+     * imperceptible except very close to the surface, where only the longest
+     * swells displace. Mainly useful to let floating objects follow the surface
+     * height.
+     */
+    displacement?: boolean;
+    /** Number of summed spectral wave components (compile-time). */
+    waveCount?: number;
+    /** Number of FBM micro-ripple octaves (compile-time). */
+    detailOctaves?: number;
+    /** Deep water colour (seen looking straight down). */
+    deepColor?: string;
+    /** Shallow/scatter water colour (seen at grazing angles). */
+    shallowColor?: string;
+    /** Base body opacity looking straight down (0 = clear, 1 = opaque). */
+    waterOpacity?: number;
+    /** Strength of the large-scale tonal variation (currents / slicks), 0 = off. */
+    tonalVariation?: number;
+    /** Approximate size of the tonal variation patches, in kilometers. */
+    tonalScale?: number;
+    /** Crispness of the tonal variation patch edges (0 = soft, 1 = hard). */
+    tonalSharpness?: number;
+    /** Colour the water drifts toward in the tonal variation (current / algae / pollution tint). */
+    tonalColor?: string;
+    /** Zenith sky colour used for the procedural reflection. */
+    skyColor?: string;
+    /** Horizon sky colour used for the procedural reflection. */
+    horizonColor?: string;
+    /** Reflection intensity multiplier. */
+    reflectionIntensity?: number;
+    /** Sun direction in world space (specular highlight + reflected glow). */
+    sunDirection?: Vec3;
+    /** Sun colour. */
+    sunColor?: string;
+    /** Sun specular shininess exponent. */
+    sunShininess?: number;
+    /** Foam colour. */
+    foamColor?: string;
+    /** Foam amount, 0 = none. */
+    foamAmount?: number;
+    /** Fresnel exponent (higher = reflections concentrated near the horizon). */
+    fresnelPower?: number;
+    /** Micro-ripple frequency (waves per world unit) for close-up detail. */
+    detailScale?: number;
+    /** Micro-ripple normal strength. */
+    detailStrength?: number;
+    /**
+     * Sea-bed base (sandy/yellowish) colour. Only used when `bedGeometry` is
+     * provided. Default `#b8a06a`.
+     */
+    seaBedColor?: string;
+    /**
+     * Strength of the water-colour tint applied to the water-facing (top) side
+     * of the sea bed (0..1). Only used when `bedGeometry` is provided.
+     */
+    seaBedWaterTint?: number;
+    /**
+     * Sea-bed opacity (0..1). Only used when `bedGeometry` is provided. The sea
+     * bed is OIT-routed, so values below 1 let the subsurface geometry below it
+     * show through; 1 (default) makes it a solid occluder.
+     */
+    seaBedOpacity?: number;
+    /**
+     * Sea-bed sand-dune relief strength (0 = off). Only used when `bedGeometry`
+     * is provided. Perturbs the bed's shading normal by a procedural,
+     * footprint-anti-aliased dune height field, adding a subtle sense of depth
+     * and scale that resolves up close and fades to flat far out. Default 0.15.
+     */
+    seaBedDuneStrength?: number;
+    /**
+     * Base sand-dune crest spacing in meters. Only used when `bedGeometry` is
+     * provided. Default 180.
+     */
+    seaBedDuneWavelength?: number;
+    /**
+     * Sand-dune ridge direction in world X/Z. Only used when `bedGeometry` is
+     * provided. Default `[1, 0.6]`.
+     */
+    seaBedDuneDirection?: Vec2;
+    /**
+     * Extra sand-dune crest/trough albedo banding (0 = off). Only used when
+     * `bedGeometry` is provided. Lightens the dune crests and darkens the
+     * troughs on top of the relief shading for a stronger depth cue; fades out
+     * far away like the rest of the dune detail. Default 0.
+     */
+    seaBedDuneSharpness?: number;
+    /**
+     * Per-meter tint build-up of the water body. Only used when `bodyGeometry`
+     * is provided.
+     */
+    bodyFogDensity?: number;
+    /** Densest water-body tint reached far through the water (0..1). */
+    bodyMaxOpacity?: number;
+    /** Animated shimmer amount of the water body, 0 = off. */
+    bodyShimmer?: number;
+    /** Master opacity multiplier (also drives OIT routing). */
+    opacity?: number;
+    /** Toggles visibility of the water-surface mesh. Default `true`. */
+    surfaceVisible?: boolean;
+    /**
+     * Toggles visibility of the water-body (side walls) mesh. Only has an effect
+     * when `bodyGeometry` is provided. Default `true`.
+     */
+    bodyVisible?: boolean;
+    /**
+     * Toggles visibility of the sea-bed mesh. Only has an effect when
+     * `bedGeometry` is provided. Default `true`.
+     */
+    bedVisible?: boolean;
+    /** Debug: render all ocean materials (surface, body, sea bed) as wireframe. */
+    wireframe?: boolean;
+    /**
+     * Children rendered inside the ocean's group, in its local frame. They
+     * receive an {@link OceanSampler} via context (see `useOceanSampler` /
+     * `useBuoyancy`) so floating objects (e.g. a vessel) can follow the waves.
+     */
+    children?: ReactNode;
+} & import('react').RefAttributes<Group<import('three').Object3DEventMap>>>;

package/dist/types/components/Ocean/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Ocean';
+export * from './ocean-bed-material';
+export * from './ocean-contact';
+export * from './ocean-material';
+export * from './ocean-sampler';
+export * from './ocean-volume-material';

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

@@ -0,0 +1,60 @@
+import { Color, ShaderMaterial, ShaderMaterialParameters, Vector2, Vector3 } from 'three';
+export type OceanBedMaterialParameters = ShaderMaterialParameters;
+/**
+ * OIT-compatible sea-bed material for the bottom face of an ocean box. Applies
+ * simple sun-direction diffuse shading so the procedural bed relief is visible,
+ * tints the water-facing (top) side toward the water colour, and keeps the
+ * underside a light sandy/yellowish colour. Rendered double-sided.
+ *
+ * At opacity 1 the OITRenderPass routes it through the opaque pass (writing
+ * depth), so it occludes geometry below it; lower opacity keeps it in the
+ * transparency passes so subsurface geometry shows through. Because the material
+ * has no `opacity` uniform, callers must mirror the alpha onto `material.opacity`
+ * to drive that routing.
+ *
+ * Wired for the OITRenderPass via {@link attachOitVariants} (variants share this
+ * material's `uniforms` by reference, so animated uniforms stay live).
+ */
+export declare class OceanBedMaterial extends ShaderMaterial {
+    isOceanBedMaterial: boolean;
+    constructor(parameters?: OceanBedMaterialParameters);
+    get color(): Color;
+    set color(value: Color | string | number);
+    get waterColor(): Color;
+    set waterColor(value: Color | string | number);
+    /** Strength of the water tint on the water-facing side (0..1). */
+    get waterTint(): number;
+    set waterTint(value: number);
+    get sunDirection(): Vector3;
+    set sunDirection(value: Vector3);
+    get sunColor(): Color;
+    set sunColor(value: Color | string | number);
+    /** Ambient light floor (0..1). */
+    get ambient(): number;
+    set ambient(value: number);
+    /** Bed opacity (also mirror onto `material.opacity` for OIT routing). */
+    get bedOpacity(): number;
+    set bedOpacity(value: number);
+    get masterOpacity(): number;
+    set masterOpacity(value: number);
+    /**
+     * Sand-dune relief strength (0 = off). Perturbs the shading normal by the
+     * analytic slope of a procedural, footprint-anti-aliased dune height field, so
+     * the bed reads with subtle relief up close and fades to flat far out.
+     */
+    get duneStrength(): number;
+    set duneStrength(value: number);
+    /** Base dune crest spacing in meters. */
+    get duneWavelength(): number;
+    set duneWavelength(value: number);
+    /** Dune ridge propagation direction in world X/Z. */
+    get duneDirection(): Vector2;
+    set duneDirection(value: Vector2);
+    /**
+     * Extra crest/trough albedo banding (0 = off). Lightens the dune crests and
+     * darkens the troughs on top of the normal-based shading for a stronger sense
+     * of relief; follows the same footprint fade so it also vanishes far out.
+     */
+    get duneSharpness(): number;
+    set duneSharpness(value: number);
+}

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

@@ -0,0 +1,39 @@
+import { OceanContact } from './ocean-material';
+/**
+ * A function returning a floating object's current contact footprint (in the
+ * ocean's local frame), or `null` when it is temporarily not touching the water
+ * (so it can be skipped). Read every frame by the enclosing `<Ocean>`, so it
+ * should reflect the object's live position/heading.
+ */
+export type OceanContactSource = () => OceanContact | null;
+/**
+ * Registry provided by an `<Ocean>` so its floating children can contribute
+ * contact-foam footprints. Floating components register a source and are
+ * unregistered automatically on unmount.
+ */
+export interface OceanContactRegistry {
+    /** Register a footprint source; returns a function that unregisters it. */
+    register(source: OceanContactSource): () => void;
+}
+/**
+ * Context carrying the enclosing `<Ocean>`'s {@link OceanContactRegistry}, or
+ * `null` when the component is not rendered inside an `<Ocean>`.
+ */
+export declare const OceanContactContext: import('react').Context<OceanContactRegistry | null>;
+/**
+ * Register a floating object's contact footprint with the enclosing `<Ocean>`
+ * so it spreads foam where it meets the water. Reusable by any floating
+ * component: pass a function that returns the object's current footprint (centre,
+ * heading and half-extents) each frame.
+ *
+ * No-op when there is no enclosing `<Ocean>` or when `enabled` is `false`. The
+ * source function is read through a ref, so it can close over changing values
+ * without re-registering every render.
+ *
+ * @example
+ * useOceanContact(
+ *   () => ({ x, z, heading, halfLength, halfWidth, foamWidth }),
+ *   enabled,
+ * );
+ */
+export declare function useOceanContact(getContact: OceanContactSource, enabled?: boolean): void;