@equinor/videx-3d 2.0.0 → 3.1.0

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;

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/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/components/Wellbores/Casings/CasingMaterial.d.ts

@@ -1,5 +1,137 @@
 import { MeshStandardMaterial, MeshStandardMaterialParameters, Uniform, WebGLProgramParametersWithUniforms } from 'three';
+/**
+ * Parameters accepted by {@link CasingMaterial}. A `MeshStandardMaterial` at heart, so
+ * it takes the familiar PBR knobs (`color`, `roughness`, `metalness`, `emissive`,
+ * `envMap`, `envMapIntensity`, ...) plus the casing texture-UV units and the grouped
+ * {@link CasingEffects | effects} below.
+ *
+ * @expand
+ */
+export type CasingMaterialParameters = MeshStandardMaterialParameters & {
+    /** UV units for the base `map` (and the aoMap/lightMap/emissiveMap/metalnessMap/
+     * roughnessMap group): `'normalized'` = 0..1 around/along, `'world'` = object-space
+     * distance (arc length x trajectory distance) so `texture.repeat` becomes a density
+     * that stays consistent across sections of different radius and length. Default
+     * `'normalized'`. */
+    mapUvUnits?: 'normalized' | 'world';
+    /** UV units for `normalMap` / `bumpMap`, independent of `mapUvUnits`. Default
+     * `'normalized'`. */
+    normalMapUvUnits?: 'normalized' | 'world';
+    /** Grouped casing stylization effects (silhouette outline, section edge shading,
+     * procedural weathering, per-section variation and micro-normal surface detail).
+     * Every sub-effect is optional and independent; omitted ones fall back to their
+     * defaults (mostly off). */
+    effects?: CasingEffects;
+};
+/**
+ * Composable casing stylization effects for {@link CasingMaterial}. Every field is
+ * optional and independent; the procedural surface-detail layers (`granular`,
+ * `brushed`, `scratches`) simply sum. Strengths default to 0 (off) unless noted.
+ * @expand
+ */
+export type CasingEffects = {
+    /** View-space silhouette darkening that outlines each shell, helping nested strings
+     * read apart (especially under slicing / auto-slice). */
+    silhouette?: {
+        /** 0-1 strength (0 = off). Default 0. */
+        strength?: number;
+        /** Exponent tightening the rim toward the edge (higher = tighter). Default 3. */
+        power?: number;
+    };
+    /** Darkening at each section's own top/bottom edges. */
+    edgeShading?: {
+        /** 0-1 strength (0 = off). Default 0. */
+        strength?: number;
+        /** Distance in metres the darkening reaches from each edge, independent of section
+         * length. Default 0.2. */
+        width?: number;
+    };
+    /** Procedural wear/tear/spill (no textures), pinned in world space. */
+    weathering?: {
+        /** 0-1 strength (0 = off). Default 0. */
+        strength?: number;
+        /** Noise frequency in cells per real-world metre (lower = larger, sparser smears).
+         * Default 1.5. */
+        scale?: number;
+        /** 0-1 per-material multiplier (1 = full wear, 0 = none) so a preset such as the
+         * matte shoe can resist the weathering. Default 1. */
+        resistance?: number;
+    };
+    /** 0-1 per-section wear variation so adjacent telescoping strings read apart by
+     * looking differently worn rather than by a colour/value ramp. Default 0. */
+    sectionVariation?: number;
+    /** 0-1 performance vs. quality of the procedural surface detail (a fill-rate knob;
+     * off-effects always cost nothing regardless). Lower = cheaper: fewer weathering fbm
+     * octaves (2 at 0 .. 4 at 1) and the coarse/long scratch family only runs at >= 0.66.
+     * 1 = full-detail reference. Default 0.6. */
+    detailQuality?: number;
+    /** Isotropic value-noise bumps. */
+    granular?: {
+        /** 0-1 strength (0 = off). Default 0. */
+        strength?: number;
+        /** Cells per world (object-distance) unit. Default 2. */
+        frequency?: number;
+        /** 1-5 fbm octaves. Default 3. */
+        octaves?: number;
+        /** 0-1 stretch of the cells along the trajectory axis. Default 0. */
+        anisotropy?: number;
+    };
+    /** Directional fine grain (many thin parallel ridges). */
+    brushed?: {
+        /** 0-1 strength (0 = off). Default 0. */
+        strength?: number;
+        /** Cells per world (object-distance) unit. Default 2. */
+        frequency?: number;
+        /** 1-5 fbm octaves. Default 3. */
+        octaves?: number;
+        /** Grain direction in radians (0 = along the trajectory axis; non-zero angles
+         * reintroduce a faint seam on a full shell). Default 0. */
+        angle?: number;
+        /** 0-1 line thinness. Default 0.5. */
+        sharpness?: number;
+        /** 0-1 blend from an irregular grain (0) to regular, evenly-spaced flutes (1).
+         * Default 0. */
+        uniformity?: number;
+    };
+    /** Sparse, hair-thin surface scuffs that glint under changing light (their relief is
+     * kept very shallow - visibility comes from a localized polish, not depth). */
+    scratches?: {
+        /** 0-1 strength (0 = off). Default 0. */
+        strength?: number;
+        /** Cells per world (object-distance) unit. Default 10. */
+        frequency?: number;
+        /** Scratch direction in radians (0 = along the trajectory axis). Default 0. */
+        angle?: number;
+        /** 0-1 how many scratches survive. Default 0.4. */
+        density?: number;
+        /** Average scratch length multiplier (>0). Default 0.6. */
+        length?: number;
+        /** 0-1 how much the scratch direction drifts. Default 1. */
+        wander?: number;
+        /** 0-1 groove width, frequency-independent (world-scaled, hair/needle-thin:
+         * ~0.02..0.12mm half-width). Default 0.15. */
+        width?: number;
+    };
+};
+/**
+ * Physically-based (PBR) material for `Casings` / `CasingSection`. A
+ * `MeshStandardMaterial` at its core - so casings pick up real image-based
+ * reflections from the scene `environment`, exactly matching neighbouring
+ * `CompletionTools` - with the casing-specific stylization (procedural weathering,
+ * granular/brushed/scratch micro-normal detail, silhouette darkening and edge shading)
+ * spliced into its shaders via `onBeforeCompile`, and the slicing/vertex
+ * transform driven by the same custom attributes as the picking material.
+ *
+ * OIT-capable via {@link makeOitCompatible} so casings participate in the
+ * `OITRenderPass` hybrid pipeline (a no-op in the default render loop).
+ */
 export declare class CasingMaterial extends MeshStandardMaterial {
+    isCasingMaterial: boolean;
+    private _weathering;
+    private _wearResistance;
+    private _wellLength;
+    /** Custom uniforms bound into the patched program in `onBeforeCompile` and
+     * shared by reference with the OIT variants so per-frame updates propagate. */
     uniforms: {
         sizeMultiplier: Uniform<number>;
         radius: Uniform<number>;
@@ -7,8 +139,40 @@ export declare class CasingMaterial extends MeshStandardMaterial {
         sliceOffset: Uniform<number>;
         sliceAngle: Uniform<number>;
         autoSlicePosition: Uniform<boolean>;
+        sectionVariation: Uniform<number>;
+        silhouette: Uniform<number>;
+        silhouettePower: Uniform<number>;
+        edgeShading: Uniform<number>;
+        edgeShadingWidth: Uniform<number>;
+        sectionIndex: Uniform<number>;
+        detailFadeNear: Uniform<number>;
+        detailFadeFar: Uniform<number>;
+        detailQuality: Uniform<number>;
+        schematic: Uniform<number>;
+        mapUvWorld: Uniform<number>;
+        normalMapUvWorld: Uniform<number>;
+        wellLength: Uniform<number>;
+        granularStrength: Uniform<number>;
+        granularFrequency: Uniform<number>;
+        granularOctaves: Uniform<number>;
+        granularAnisotropy: Uniform<number>;
+        brushedStrength: Uniform<number>;
+        brushedFrequency: Uniform<number>;
+        brushedOctaves: Uniform<number>;
+        brushedAngle: Uniform<number>;
+        brushedSharpness: Uniform<number>;
+        brushedUniformity: Uniform<number>;
+        scratchStrength: Uniform<number>;
+        scratchFrequency: Uniform<number>;
+        scratchAngle: Uniform<number>;
+        scratchDensity: Uniform<number>;
+        scratchLength: Uniform<number>;
+        scratchWander: Uniform<number>;
+        scratchWidth: Uniform<number>;
+        weathering: Uniform<number>;
+        weatheringScale: Uniform<number>;
     };
-    constructor(params?: MeshStandardMaterialParameters);
+    constructor(parameters?: CasingMaterialParameters);
     get sizeMultiplier(): number;
     set sizeMultiplier(v: number);
     get radius(): number;
@@ -21,5 +185,69 @@ export declare class CasingMaterial extends MeshStandardMaterial {
     set sliceAngle(v: number);
     get autoSlicePosition(): boolean;
     set autoSlicePosition(v: boolean);
+    /** 0-1 strength of the per-section wear variation: how much each section's
+     * procedural wear is offset (seed) and scaled (amount) by its index, so adjacent
+     * telescoping strings read apart by looking differently worn rather than by a
+     * colour/value ramp. */
+    get sectionVariation(): number;
+    set sectionVariation(v: number);
+    /** 0-1 strength of the view-space silhouette darkening (outlines each shell). */
+    get silhouette(): number;
+    set silhouette(v: number);
+    /** Exponent tightening the silhouette rim toward the edge (higher = tighter). Default 3. */
+    get silhouettePower(): number;
+    set silhouettePower(v: number);
+    /** 0-1 strength of the edge shading (darkening at each section's own top/bottom edges). */
+    get edgeShading(): number;
+    set edgeShading(v: number);
+    /** Distance in metres the edge shading reaches from each section edge. Default 0.2. */
+    get edgeShadingWidth(): number;
+    set edgeShadingWidth(v: number);
+    /** Index of this section within the wellbore's casing stack, used to seed the
+     * per-section variation of the stylization effects. */
+    get sectionIndex(): number;
+    set sectionIndex(v: number);
+    /** 0-1 performance vs. quality of the procedural surface detail (fill-rate knob).
+     * Lower = cheaper (fewer weathering fbm octaves; the coarse scratch family only runs
+     * at >= 0.66); 1 = full-detail reference. */
+    get detailQuality(): number;
+    set detailQuality(v: number);
+    /** Unlit "schematic" shading mode: flat material `color` + `silhouette` outline only,
+     * with all lighting/env, textures and realism detail ignored. Set by the `Casings`
+     * component's `schematic` prop; the slice is locked separately (component side). */
+    get schematic(): boolean;
+    set schematic(v: boolean);
+    /** 0-1 strength of the procedural wear/tear/spill surface detail (no textures). The
+     * effective amount is scaled per-material by {@link wearResistance}. */
+    get weathering(): number;
+    set weathering(v: number);
+    /** 0-1 per-material wear multiplier (1 = full wear, 0 = none). Lets material presets
+     * (e.g. the matte shoe) resist the procedural weathering the component applies
+     * globally via {@link weathering}. */
+    get wearResistance(): number;
+    set wearResistance(v: number);
+    /** Weathering noise frequency in cells per real-world metre (lower = larger,
+     * sparser smears). */
+    get weatheringScale(): number;
+    set weatheringScale(v: number);
+    /** Real-world total length (metres) of the whole wellbore trajectory. Uploaded as a
+     * uniform and used by the vertex shader to derive each section's physical length
+     * (`vSectionLength`) and the along-axis coordinate (`casingAxial`). The weathering is
+     * pinned in world space (via `vWorldPos`) and does not use it. */
+    get wellLength(): number;
+    set wellLength(v: number);
+    /** UV units for the base `map` group. `'world'` uses object-space distance so
+     * `texture.repeat` is a radius/length-consistent density. */
+    get mapUvUnits(): 'normalized' | 'world';
+    set mapUvUnits(v: 'normalized' | 'world');
+    /** UV units for `normalMap` / `bumpMap`, independent of {@link mapUvUnits}. */
+    get normalMapUvUnits(): 'normalized' | 'world';
+    set normalMapUvUnits(v: 'normalized' | 'world');
+    /** Grouped casing stylization effects (silhouette, edge shading, weathering,
+     * per-section variation and the granular/brushed/scratch micro-normal layers).
+     * Reading returns the current settings reconstructed from the uniforms. Assigning
+     * applies the whole group at once - omitted sub-effects reset to their defaults. */
+    get effects(): CasingEffects;
+    set effects(v: CasingEffects | undefined);
     onBeforeCompile(parameters: WebGLProgramParametersWithUniforms): void;
 }