@call-me-sensei/toonlab 0.4.21 → 0.4.23

package/types/rockgen/surface/naturalRockSurface.d.ts

@@ -0,0 +1,100 @@
+export type NaturalRockMapRole = 'ao' | 'baseColor' | 'heightMicro' | 'normalGL' | 'orm' | 'roughness' | 'smoothness';
+export type NaturalRockVector = readonly [number, number, number];
+export type NaturalRockBounds = NaturalRockVector | {
+  dimensionsMetres?: readonly number[];
+  dimensions?: readonly number[];
+  minimum?: readonly number[];
+  maximum?: readonly number[];
+  min?: readonly number[];
+  max?: readonly number[];
+  width?: number;
+  height?: number;
+  depth?: number;
+};
+export interface NaturalRockProfile {
+  readonly label: string;
+  readonly lithology: string;
+  readonly fabric: string;
+  readonly requiresSemanticRegions?: boolean;
+  readonly semanticRegionRoles?: readonly string[] | null;
+  readonly baseTileMetres: number;
+  readonly heightMicroSpanMetres: number;
+  readonly [property: string]: unknown;
+}
+export interface NaturalRockBinding {
+  familyId: string;
+  profileId: string;
+  surfaceRationale?: string;
+  requiresSemanticRegions?: boolean;
+}
+export interface NaturalRockPackedMask {
+  encoding: 'rle-u8-v1'; length: number; runs: readonly number[];
+}
+export interface NaturalRockSemanticRegions {
+  schema: 'toonlab/c8-semantic-surface-regions'; version: 1;
+  coordinateSpace: 'geometry-uv0'; geometrySha256: string; width: number; height: number;
+  regions: readonly {
+    id: string; role: string; materialProfileId: string; geometryRegionId: string;
+    sourceKind: 'authored-geometry-semantic-mask';
+    mask: Uint8Array | NaturalRockPackedMask; maskSha256?: string;
+  }[];
+}
+export interface NaturalRockSurfaceOptions {
+  assetId: string;
+  profileId?: string | null;
+  binding?: NaturalRockBinding | null;
+  seed?: number | null;
+  semanticRegions?: NaturalRockSemanticRegions | null;
+  geometrySha256?: string | null;
+}
+export interface NaturalRockProjection {
+  readonly mode: string;
+  readonly upAxis: 'y';
+  readonly scaleMetres?: number;
+  readonly dimensionsMetres?: readonly number[];
+  readonly mapRoleProjection: Readonly<Record<NaturalRockMapRole, Readonly<Record<string, unknown>>>>;
+  readonly [property: string]: unknown;
+}
+export interface NaturalRockSurfaceSpecification {
+  readonly assetId: string;
+  readonly profileId: string;
+  readonly schema: string;
+  readonly version: number;
+  readonly seed: number;
+  readonly mapResolution: number;
+  readonly geometrySha256: string;
+  readonly projection: NaturalRockProjection;
+  readonly semanticRegions?: NaturalRockSemanticRegions;
+  readonly semanticRegionSurface?: Readonly<{ contractSha256: string; geometrySha256: string; [property: string]: unknown }>;
+  readonly [property: string]: unknown;
+}
+export const C8_FIRST12_LITHOLOGY_PROFILES: Readonly<Record<string, NaturalRockProfile>>;
+export const C8_FIRST12_MAP_ROLES: readonly NaturalRockMapRole[];
+export const C8_FIRST12_ASSET_IDS: readonly string[];
+export const C8_FIRST12_ASSET_SURFACE_BINDINGS: Readonly<Record<string, NaturalRockBinding>>;
+export const C8_COMPOSITE_SURFACE_RECIPES: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+export const C8_FIRST12_SURFACE_SCHEMA: 'toonlab/c8-first12-geology-surface';
+export const C8_FIRST12_SURFACE_VERSION: 2;
+export const C8_SEMANTIC_SURFACE_REGIONS_SCHEMA: 'toonlab/c8-semantic-surface-regions';
+export const C8_SEMANTIC_SURFACE_REGIONS_VERSION: 1;
+export function c8First12SurfaceSeed(value: unknown): number;
+export function normalizeC8First12EditedBounds(bounds: NaturalRockBounds): Readonly<{
+  axisOrder: 'x-y-z'; dimensionsMetres: readonly number[];
+  maximumMetres: readonly number[] | null; minimumMetres: readonly number[] | null; upAxis: 'y';
+}>;
+export function resolveC8First12Projection(options: {
+  assetId: string; editedBoundsMetres: NaturalRockBounds;
+  profileId?: string | null; binding?: NaturalRockBinding | null;
+}): NaturalRockProjection;
+export function createC8First12GeologyMapData(options: NaturalRockSurfaceOptions & {
+  size?: number; projectionScaleMetres?: number | null;
+}): Readonly<{
+  maps: Readonly<Record<NaturalRockMapRole, Uint8Array>>;
+  audit: Readonly<{ profileId: string; seed: number; size: number; byteHash: string; [property: string]: unknown }>;
+  heightMicroDecode: Readonly<{ encoding: string; midlevel: number; physicalSpanMetres: number; [property: string]: unknown }>;
+  normalGLDerivation: Readonly<Record<string, unknown>>;
+}>;
+export function createC8First12SurfaceSpecification(options: NaturalRockSurfaceOptions & {
+  editedBoundsMetres: NaturalRockBounds; geometrySha256: string;
+  mapResolution?: number; boundsAuthority?: string;
+}): NaturalRockSurfaceSpecification;

package/types/shaders-tsl/chunks/projected-water-caustics.d.ts

@@ -1,5 +1,8 @@
 /** Refresh the shared receiver from the active WaterSurface once per frame. */
-export function updateProjectedWaterCaustics({ enabled, time, waterLevel, centerX, centerZ, halfWidth, halfDepth, color, intensity, scale, speed, flowDirection, waveDistortion, depthAttenuation, }?: {}): void;
+export function updateProjectedWaterCaustics({ enabled, time, waterLevel, centerX, centerZ, halfWidth, halfDepth, color, intensity, scale, speed, flowDirection, waveDistortion, depthAttenuation, surfaceMap, surfaceRegion, }?: {
+    surfaceMap?: any;
+    surfaceRegion?: any;
+}): void;
 /**
  * Returns additive underwater caustic light for a world position/normal.
  * This deliberately stays branchless. A previous TSL `If`-wrapped version
@@ -9,6 +12,9 @@ export function updateProjectedWaterCaustics({ enabled, time, waterLevel, center
 export function projectedWaterCaustics(worldPosition: any, worldNormal: any): import("three/webgpu").Node<"vec3">;
 export namespace projectedWaterCausticUniforms {
     let map: import("three/webgpu").TextureNode<"vec4">;
+    let surfaceMap: import("three/webgpu").TextureNode<"vec4">;
+    let useSurfaceMap: import("three/webgpu").UniformNode<"float", number>;
+    let surfaceRegion: import("three/webgpu").UniformNode<"vec4", THREE.Vector4>;
     let enabled: import("three/webgpu").UniformNode<"float", number>;
     let time: import("three/webgpu").UniformNode<"float", number>;
     let waterLevel: import("three/webgpu").UniformNode<"float", number>;

package/types/shaders-tsl/chunks/water-lighting.d.ts

@@ -1,9 +1,10 @@
-export function createWaterLightingChunk({ u }: {
+export function createWaterLightingChunk({ u, physicalSurface }: {
     u: any;
+    physicalSurface?: boolean;
 }): {
-    fresnelFactor: (viewDir: any, surfaceNormal: any) => import("three/webgpu").Node<"float">;
+    fresnelFactor: (viewDir: any, surfaceNormal: any) => any;
     proceduralSky: (reflectDir: any) => import("three/webgpu").Node<"float">;
     reflectionColor: (worldPosition: any, surfaceNormal: any, viewDir: any) => import("three/webgpu").VarNode<"vec3", import("three/webgpu").VarNode<"vec3", import("three/webgpu").ConvertNode<"vec3">>>;
-    sparkles: (restXZ: any, surfaceNormal: any, viewDir: any, viewDistance: any, time: any) => import("three/webgpu").VarNode<"vec3", import("three/webgpu").VarNode<"vec3", import("three/webgpu").ConstNode<"vec3", import("three").Vector3>>>;
+    sparkles: (restXZ: any, surfaceNormal: any, viewDir: any, viewDistance: any, time: any) => import("three/webgpu").Node<"vec3">;
     specular: (viewDir: any, surfaceNormal: any, shadowFactor: any) => any;
 };

package/types/shaders-tsl/water.d.ts

@@ -13,10 +13,11 @@ export function resolveWaterArrayUniformNode(entry: any): any;
  * - foamOctaves      WATER_FOAM_OCTAVES
  * - shoaling         WATER_SHOALING (aBedHeight attribute present)
  */
-export function createWaterNodeMaterial({ waveCount, qualityLevel, detailOctaves, foamOctaves, shoaling, }?: {
+export function createWaterNodeMaterial({ waveCount, qualityLevel, detailOctaves, foamOctaves, shoaling, dynamics, }?: {
     qualityLevel?: number;
     detailOctaves?: number;
     foamOctaves?: number;
     shoaling?: boolean;
+    dynamics?: boolean;
 }): NodeMaterial;
 import { NodeMaterial } from 'three/webgpu';

package/types/version.d.ts

@@ -1 +1 @@
-export const TOONLAB_VERSION: "0.4.21";
+export const TOONLAB_VERSION: "0.4.23";

package/types/water/waterDetailSpectrum.d.ts

@@ -0,0 +1,13 @@
+export class WaterDetailSpectrum {
+    size: number;
+    signature: string;
+    time: number;
+    bands: {
+        length: number;
+        baseLength: number;
+    }[];
+    configure(settings: any): void;
+    update(time: any): void;
+    sample(x: any, z: any, out: any): any;
+    dispose(): void;
+}

package/types/water/waterDynamics.d.ts

@@ -0,0 +1,89 @@
+export class WaterDynamics {
+    constructor(surface: any, options?: {});
+    surface: any;
+    isWaterDynamics: boolean;
+    options: {};
+    mode: any;
+    time: number;
+    columns: any;
+    rows: any;
+    state: Float32Array<ArrayBuffer>;
+    normals: Float32Array<ArrayBuffer>;
+    history: Float32Array<ArrayBuffer>;
+    foamCoordinates: Float32Array<ArrayBuffer>;
+    previousFoamCoordinates: Float32Array<ArrayBuffer>;
+    shoreDistances: Float32Array<ArrayBuffer>;
+    shoreContour: Float32Array<any>;
+    causticResolution: number;
+    light: Float32Array<ArrayBuffer>;
+    causticWork: Float64Array<ArrayBuffer>;
+    causticRegion: THREE.Vector4;
+    previousFoam: Float32Array<ArrayBuffer>;
+    stateAttribute: THREE.BufferAttribute<THREE.BufferAttributeEventMap>;
+    normalAttribute: THREE.BufferAttribute<THREE.BufferAttributeEventMap>;
+    texture: THREE.DataTexture;
+    foamCoordinateTexture: THREE.DataTexture;
+    causticTexture: THREE.DataTexture;
+    spectrum: WaterSpectralOcean;
+    normalSpectrum: WaterSpectralOcean;
+    detailSpectrum: WaterDetailSpectrum;
+    normalTextures: THREE.DataTexture[];
+    gridSignature: string;
+    reference: boolean;
+    paused: boolean;
+    pendingStep: number;
+    sampleScratch: {};
+    settingsSignature: string;
+    getRegion(out?: THREE.Vector4): THREE.Vector4;
+    rebuild(): void;
+    foamParticles: any;
+    renderExtension: any;
+    x: any;
+    z: any;
+    level: any;
+    dx: number;
+    dz: number;
+    minX: number;
+    minZ: number;
+    bed: any;
+    hydro: WaterHydrodynamics;
+    interactions: WaterHydrodynamics;
+    warmupRemaining: number;
+    boundary(side: any, x: any, z: any, time: any, ghost: any): boolean;
+    update(delta: any): void;
+    incidentWaves: {
+        dirX: number;
+        dirZ: number;
+        omega: number;
+        waveNumber: number;
+        amplitude: number;
+        phase: number;
+        steepness: number;
+        crestWeight: number;
+    }[];
+    updateShoreContour(): void;
+    updateFoamCoordinates(dt: any): void;
+    updateCaustics(): void;
+    sample(x: any, z: any, out?: {}): {};
+    impulse(x: any, z: any, strength: any, radius: any): void;
+    shoreEdgeAt(x?: number, minimumDepth?: number): number;
+    diagnostics(): {
+        time: number;
+        steps: number;
+        volume: number;
+        boundaryVolume: number;
+        massError: number;
+        roundoffVolume: number;
+        minDepth: any;
+    } | {
+        time: number;
+        model: string;
+        bands: number;
+        peakLength: number;
+    };
+    dispose(): void;
+}
+import * as THREE from 'three';
+import { WaterSpectralOcean } from './waterSpectralOcean.js';
+import { WaterDetailSpectrum } from './waterDetailSpectrum.js';
+import { WaterHydrodynamics } from './waterHydrodynamics.js';

package/types/water/waterFoamParticles.d.ts

@@ -0,0 +1,32 @@
+export class WaterFoamParticles {
+    constructor(dynamics: any, count?: number);
+    dynamics: any;
+    count: number;
+    seed: number;
+    points: Float32Array<ArrayBuffer>;
+    thickness: Float32Array<ArrayBuffer>;
+    alpha: Float32Array<ArrayBuffer>;
+    color: import("three/webgpu").UniformNode<"color", THREE.Color>;
+    sun: import("three/webgpu").UniformNode<"vec3", THREE.Vector3>;
+    mesh: THREE.InstancedMesh<THREE.PlaneGeometry, MeshBasicNodeMaterial, THREE.InstancedMeshEventMap>;
+    focus: THREE.Vector3;
+    sample: {};
+    alive: number;
+    frontState: Float32Array<ArrayBuffer>;
+    previousEdges: Float32Array<any>;
+    frontReady: boolean;
+    frontTexture: THREE.DataTexture;
+    random(): number;
+    concentration(x: any, z: any): any;
+    edgeAt(x: any): any;
+    sampleFront(x: any, component: any, previous?: boolean): number;
+    updateFront(dt: any): void;
+    retreatAt(x: any): number;
+    patchAt(x: any, edge: any): number;
+    networkAt(x: any, z: any): number;
+    availableFoam(x: any, z: any): any;
+    update(dt: any): void;
+    dispose(): void;
+}
+import * as THREE from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';

package/types/water/waterFoamTexture.d.ts

@@ -0,0 +1 @@
+export function getWaterFoamTexture(): any;

package/types/water/waterHydrodynamics.d.ts

@@ -0,0 +1,49 @@
+export class WaterHydrodynamics {
+    constructor({ columns, rows, width, depth, centerX, centerZ, waterLevel, bedHeight, boundary, friction }?: {
+        columns?: number;
+        rows?: number;
+        width?: number;
+        depth?: number;
+        centerX?: number;
+        centerZ?: number;
+        waterLevel?: number;
+        bedHeight?: () => number;
+        boundary?: any;
+        friction?: number;
+    });
+    dx: number;
+    dz: number;
+    minX: number;
+    minZ: number;
+    length: number;
+    time: number;
+    boundaryVolume: number;
+    roundoffVolume: number;
+    initialVolume: number;
+    steps: number;
+    foamLifetime: number;
+    foamResidueLifetime: number;
+    ghost: {
+        h: number;
+        qx: number;
+        qz: number;
+        bed: number;
+    };
+    volume(): number;
+    diagnostics(): {
+        time: number;
+        steps: number;
+        volume: number;
+        boundaryVolume: number;
+        massError: number;
+        roundoffVolume: number;
+        minDepth: any;
+    };
+    impulse(x: any, z: any, strength?: number, radius?: number, direction?: any): void;
+    face(left: any, right: any, axis: any, dt: any): void;
+    boundaryFace(i: any, side: any, axis: any, low: any, dt: any): void;
+    advance(duration: any): void;
+    step(dt: any): void;
+    sampleArray(array: any, x: any, z: any): number;
+    sample(x: any, z: any, out?: {}): {};
+}

package/types/water/waterRenderExtension.d.ts

@@ -0,0 +1,16 @@
+export class WaterRenderExtension {
+    constructor(dynamics: any, extent: any);
+    dynamics: any;
+    xs: any[];
+    zs: any[];
+    geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+    states: Float32Array<ArrayBuffer>;
+    normals: Float32Array<ArrayBuffer>;
+    wetDistances: Float32Array<ArrayBuffer>;
+    mesh: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, any, THREE.Object3DEventMap>;
+    sample: {};
+    incoming(x: any, z: any, stepX?: number, stepZ?: number): number;
+    update(): void;
+    dispose(): void;
+}
+import * as THREE from 'three';

package/types/water/waterScenePasses.d.ts

@@ -59,7 +59,7 @@ export class WaterScenePasses {
     depthMaterialFor(material: any): any;
     renderDepthPass(renderer: any, scene: any, camera: any): void;
     renderGrabPass(renderer: any, scene: any, camera: any, waterMesh: any): void;
-    applyWaterClipPlane(renderer: any, camera: any, waterY: any): void;
+    applyWaterClipPlane(renderer: any, camera: any, waterY: any, side?: number): void;
     updateTransmissionCamera(renderer: any, camera: any, waterY: any): THREE.PerspectiveCamera;
     updateReflectionCamera(renderer: any, camera: any, waterY: any): boolean;
     renderReflectionPass(renderer: any, scene: any, camera: any, waterMesh: any): void;

package/types/water/waterSettings.d.ts

@@ -228,6 +228,7 @@ export function sampleSwashFrameState(waves: any, time: any, runupDistance?: num
     primaryDirectionZ: any;
     progress: number;
     progressSpeed: number;
+    activity: number;
     runupScale: number;
     startOffset: number;
     endOffset: number;

package/types/water/waterSpectralOcean.d.ts

@@ -0,0 +1,17 @@
+export function inverseFFT2D(real: any, imaginary: any, size: any): void;
+export class WaterSpectralOcean {
+    constructor({ resolution, seed }?: {
+        resolution?: number;
+        seed?: number;
+    });
+    resolution: number;
+    seed: number;
+    bands: any[];
+    signature: string;
+    time: number;
+    configure(settings: any, depth?: number, minWavelength?: number): void;
+    peakLength: number;
+    rms: number;
+    update(time: any): void;
+    sample(x: any, z: any, minWavelength?: number): number;
+}

package/types/water/waterStageSettings.d.ts

@@ -1,7 +1,7 @@
 export function waterStageOverrides(stage: any, baseSettings?: {}): {};
 export const BEACH_RUNUP_DISTANCE: 10;
 export const BEACH_WATER_LEVEL: 0.36;
-export const BEACH_WAVE_SPEED: 0.35;
+export const BEACH_WAVE_SPEED: 0.65;
 export const BEACH_DIRECTION_SPREAD: 0.18;
 export const SHOREWARD_ORIENTATION: Readonly<{
     flowDirection: readonly number[];

package/types/water/waterUnderwaterAtmosphere.d.ts

@@ -8,6 +8,7 @@ export function createWaterUnderwaterAtmosphereOptions(options?: boolean): {
     boundsMargin: 0;
     clearFogNode: true;
     color?: undefined;
+    waterPathFog?: undefined;
 } | {
     enabled: any;
     fogNear: number;
@@ -18,14 +19,17 @@ export function createWaterUnderwaterAtmosphereOptions(options?: boolean): {
     clipToSurfaceBounds: any;
     boundsMargin: number;
     clearFogNode: any;
+    waterPathFog: any;
 };
-export function resolveWaterUnderwaterAtmosphereState({ cameraX, cameraY, cameraZ, waterX, waterY, waterZ, width, depth, settings, options, }?: {
+export function resolveWaterUnderwaterAtmosphereState({ cameraX, cameraY, cameraZ, waterX, waterY, waterZ, surfaceY, bedY, width, depth, settings, options, }?: {
     cameraX?: number;
     cameraY?: number;
     cameraZ?: number;
     waterX?: number;
     waterY?: number;
     waterZ?: number;
+    surfaceY?: any;
+    bedY?: number;
     width?: number;
     depth?: number;
     settings?: {};
@@ -39,7 +43,10 @@ export function resolveWaterUnderwaterAtmosphereState({ cameraX, cameraY, camera
     fogFar: number;
     overlayOpacity: number;
     clearFogNode: any;
-    waterY: number;
+    waterPathFog: any;
+    waterY: any;
+    surfaceY: any;
+    bedY: number;
 };
 export const DEFAULT_WATER_UNDERWATER_ATMOSPHERE: Readonly<{
     enabled: true;
@@ -63,6 +70,7 @@ export class WaterUnderwaterAtmosphere {
         boundsMargin: 0;
         clearFogNode: true;
         color?: undefined;
+        waterPathFog?: undefined;
     } | {
         enabled: any;
         fogNear: number;
@@ -73,6 +81,7 @@ export class WaterUnderwaterAtmosphere {
         clipToSurfaceBounds: any;
         boundsMargin: number;
         clearFogNode: any;
+        waterPathFog: any;
     };
     scene: any;
     state: {
@@ -84,7 +93,10 @@ export class WaterUnderwaterAtmosphere {
         fogFar: number;
         overlayOpacity: number;
         clearFogNode: any;
-        waterY: number;
+        waterPathFog: any;
+        waterY: any;
+        surfaceY: any;
+        bedY: number;
     };
     detach(): void;
     beginFrame(scene: any): void;
@@ -97,7 +109,10 @@ export class WaterUnderwaterAtmosphere {
         fogFar: number;
         overlayOpacity: number;
         clearFogNode: any;
-        waterY: number;
+        waterPathFog: any;
+        waterY: any;
+        surfaceY: any;
+        bedY: number;
     };
     dispose(): void;
 }