@takram/three-geospatial 0.8.0 → 0.9.0

package/src/webgpu/sampling.ts

@@ -1,16 +1,50 @@
-import { add, sub, textureSize, vec2 } from 'three/tsl'
-import type { TextureNode } from 'three/webgpu'
+import { add, ivec2, ivec4, sub, uv, vec2, vec4 } from 'three/tsl'
+import type { ConstNode, TextureNode } from 'three/webgpu'
 
+import { reinterpretType } from '../types'
 import { FnVar } from './FnVar'
 import type { Node } from './node'
 
+const components = ['x', 'y', 'z', 'w'] as const
+
+// WORKAROUND: TextureNode doesn't have gather() yet.
+// See: https://www.w3.org/TR/WGSL/#texturegather
+export const textureGather = /*#__PURE__*/ FnVar(
+  (
+    textureNode: TextureNode,
+    uvNode: Node<'vec2'>,
+    component = 0
+  ): Node<'vec4'> => {
+    let componentValue
+    if (typeof component === 'number') {
+      componentValue = component
+    } else if ((component as any)?.isConstNode === true) {
+      reinterpretType<ConstNode<number>>(component)
+      componentValue = component.value
+    } else {
+      throw new Error('Component must be a constant.')
+    }
+
+    const size = textureNode.size()
+    const coord = ivec2(uvNode.mul(size).sub(0.5).floor()).toConst()
+    const i = ivec4(coord, coord.add(1)).toConst()
+    const c = components[componentValue] // element() fails for depth textures
+    return vec4(
+      textureNode.load(i.xw)[c], // min, max
+      textureNode.load(i.zw)[c], // max, max
+      textureNode.load(i.zy)[c], // max, min
+      textureNode.load(i.xy)[c] // min, min
+    )
+  }
+)
+
 // 9-taps version of Catmull-Rom sampling.
 // Reference: https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
 export const textureCatmullRom = /*#__PURE__*/ FnVar(
-  (textureNode: TextureNode, uv: Node<'vec2'>): Node<'vec4'> => {
-    const size = vec2(textureSize(textureNode))
+  (textureNode: TextureNode, uvNode: Node<'vec2'> = uv()): Node<'vec4'> => {
+    const size = vec2(textureNode.size())
     const texelSize = size.reciprocal()
-    const position = uv.mul(size)
+    const position = uvNode.mul(size)
     const centerPosition = position.sub(0.5).floor().add(0.5)
 
     // Compute the fractional offset from our starting texel to our original

package/src/webgpu/transformations.ts

@@ -1,4 +1,7 @@
+import type { Camera } from 'three'
 import {
+  cameraFar as cameraFarTSL,
+  cameraNear as cameraNearTSL,
   cos,
   int,
   logarithmicDepthToViewZ,
@@ -14,44 +17,54 @@ import {
   viewZToPerspectiveDepth
 } from 'three/tsl'
 
+import { cameraFar, cameraNear } from './accessors'
+import { FnLayout } from './FnLayout'
+import { FnVar } from './FnVar'
 import type { Node } from './node'
 
-export interface DepthOptions {
-  perspective?: boolean
-  logarithmic?: boolean
-}
-
-export const depthToViewZ = (
-  depth: Node<'float'>,
-  near: Node<'float'>,
-  far: Node<'float'>,
-  { perspective = true, logarithmic = false }: DepthOptions = {}
-): Node<'float'> => {
-  return logarithmic
-    ? logarithmicDepthToViewZ(depth, near, far)
-    : perspective
-      ? perspectiveDepthToViewZ(depth, near, far)
-      : orthographicDepthToViewZ(depth, near, far)
-}
+export const depthToViewZ = /*#__PURE__*/ FnVar(
+  (
+    depth: Node<'float'>,
+    camera?: Camera | null,
+    near?: Node<'float'> | null,
+    far?: Node<'float'> | null
+  ) =>
+    (builder): Node<'float'> => {
+      near ??= cameraNear(camera)
+      far ??= cameraFar(camera)
+      const perspective = camera?.isPerspectiveCamera === true
+      const logarithmic = builder.renderer.logarithmicDepthBuffer
+      return logarithmic
+        ? logarithmicDepthToViewZ(depth, near, far)
+        : perspective
+          ? perspectiveDepthToViewZ(depth, near, far)
+          : orthographicDepthToViewZ(depth, near, far)
+    }
+)
 
 export const logarithmicToPerspectiveDepth = (
   depth: Node<'float'>,
-  near: Node<'float'>,
-  far: Node<'float'>
+  near?: Node<'float'> | null,
+  far?: Node<'float'> | null
 ): Node<'float'> => {
+  near ??= cameraNearTSL
+  far ??= cameraFarTSL
   const viewZ = logarithmicDepthToViewZ(depth, near, far)
   return viewZToPerspectiveDepth(viewZ, near, far)
 }
 
 export const perspectiveToLogarithmicDepth = (
   depth: Node<'float'>,
-  near: Node<'float'>,
-  far: Node<'float'>
+  near?: Node<'float'> | null,
+  far?: Node<'float'> | null
 ): Node<'float'> => {
+  near ??= cameraNearTSL
+  far ??= cameraFarTSL
   const viewZ = perspectiveDepthToViewZ(depth, near, far)
   return viewZToLogarithmicDepth(viewZ, near, far)
 }
 
+// TODO: Reconsider interface
 export const screenToPositionView = (
   uv: Node<'vec2'>,
   depth: Node<'float'>,
@@ -68,34 +81,48 @@ export const screenToPositionView = (
 
 // A fifth-order polynomial approximation of Turbo color map.
 // See: https://observablehq.com/@mbostock/turbo
-const turboCoeffs = [
-  /*#__PURE__*/ vec3(58.1375, 2.7747, 26.8183),
-  /*#__PURE__*/ vec3(-150.5666, 4.2109, -88.5066),
-  /*#__PURE__*/ vec3(130.5887, -14.0195, 109.0745),
-  /*#__PURE__*/ vec3(-42.3277, 4.8052, -60.1097),
-  /*#__PURE__*/ vec3(4.5974, 2.1856, 12.5925),
-  /*#__PURE__*/ vec3(0.1357, 0.0914, 0.1067)
+const turboCoeffs: ReadonlyArray<[number, number, number]> = [
+  [58.1375, 2.7747, 26.8183],
+  [-150.5666, 4.2109, -88.5066],
+  [130.5887, -14.0195, 109.0745],
+  [-42.3277, 4.8052, -60.1097],
+  [4.5974, 2.1856, 12.5925],
+  [0.1357, 0.0914, 0.1067]
 ]
 
-export const turbo = (x: Node<'float'>): Node<'vec3'> => {
-  return turboCoeffs
-    .slice(1)
-    .reduce<Node>((y, offset) => offset.add(x.mul(y)), turboCoeffs[0])
-}
+export const turbo = /*#__PURE__*/ FnLayout({
+  name: 'turbo',
+  type: 'vec3',
+  inputs: [{ name: 'x', type: 'float' }]
+})(([x]) => {
+  const y = vec3(...turboCoeffs[0]).toVar()
+  for (let i = 1; i < turboCoeffs.length; ++i) {
+    y.assign(vec3(...turboCoeffs[i]).add(x.mul(y)))
+  }
+  return y
+})
 
-export const depthToColor = (
-  depth: Node<'float'>,
-  near: Node<'float'>,
-  far: Node<'float'>,
-  options?: DepthOptions
-): Node<'vec3'> => {
-  const viewZ = depthToViewZ(depth, near, far, options)
-  return turbo(viewZToLogarithmicDepth(viewZ, near, far))
-}
+export const depthToColor = FnVar(
+  (
+    depth: Node<'float'>,
+    camera?: Camera,
+    near?: Node<'float'>,
+    far?: Node<'float'>
+  ): Node<'vec3'> => {
+    near ??= cameraNear(camera)
+    far ??= cameraFar(camera)
+    const viewZ = depthToViewZ(depth, camera, near, far)
+    return turbo(viewZToLogarithmicDepth(viewZ, near, far))
+  }
+)
 
-export const equirectToDirectionWorld = (uv: Node<'vec2'>): Node<'vec3'> => {
+export const equirectToDirectionWorld = /*#__PURE__*/ FnLayout({
+  name: 'equirectToDirectionWorld',
+  type: 'vec3',
+  inputs: [{ name: 'uv', type: 'vec2' }]
+})(([uv]) => {
   const lambda = sub(0.5, uv.x).mul(PI2)
   const phi = sub(uv.y, 0.5).mul(PI)
   const cosPhi = cos(phi)
   return vec3(cosPhi.mul(cos(lambda)), sin(phi), cosPhi.mul(sin(lambda)))
-}
+})

package/types/PointOfView.d.ts

@@ -15,5 +15,5 @@ export declare class PointOfView {
     copy(other: PointOfView): this;
     equals(other: PointOfView): boolean;
     decompose(target: Vector3, eye: Vector3, quaternion: Quaternion, up?: Vector3, ellipsoid?: Ellipsoid): void;
-    setFromCamera(camera: Camera, ellipsoid?: Ellipsoid): this | undefined;
+    setFromCamera(camera: Camera, ellipsoid?: Ellipsoid, target?: Vector3): this | undefined;
 }

package/types/STBNLoader.d.ts

@@ -1,5 +1,4 @@
-import { Data3DTexture, LoadingManager } from 'three';
-import { DataTextureLoader } from './DataTextureLoader';
-export declare class STBNLoader extends DataTextureLoader<Data3DTexture> {
-    constructor(manager?: LoadingManager);
+import { Data3DTexture, Loader } from 'three';
+export declare class STBNLoader extends Loader<Data3DTexture> {
+    load(url: string, onLoad?: (data: Data3DTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): Data3DTexture;
 }

package/types/webgpu/CascadedShadowMapsNode.d.ts

@@ -0,0 +1,13 @@
+import { DirectionalLight, PerspectiveCamera, Vector2 } from 'three';
+import { CSMShadowNode } from 'three/examples/jsm/csm/CSMShadowNode.js';
+import { NodeFrame } from 'three/webgpu';
+declare module 'three/examples/jsm/csm/CSMShadowNode.js' {
+    interface CSMShadowNode {
+        _cascades: Vector2[];
+    }
+}
+export declare class CascadedShadowMapsNode extends CSMShadowNode {
+    camera: PerspectiveCamera;
+    light: DirectionalLight;
+    updateBefore(frame: NodeFrame): void;
+}

package/types/webgpu/DualMipmapFilterNode.d.ts

@@ -1,4 +1,3 @@
-import { Vector2 } from 'three';
 import { NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 import { FilterNode } from './FilterNode';
 import { Node } from './node';
@@ -9,7 +8,7 @@ export declare abstract class DualMipmapFilterNode extends FilterNode {
     private readonly upsampleMaterial;
     private readonly mesh;
     private rendererState?;
-    protected readonly inputTexelSize: import('three/webgpu').UniformNode<Vector2>;
+    protected readonly inputTexelSize: import('three/webgpu').UniformNode<import('three').Vector2>;
     protected readonly downsampleNode: TextureNode;
     constructor(inputNode: TextureNode | null | undefined, levels: number);
     setSize(width: number, height: number): this;

package/types/webgpu/FnLayout.d.ts

@@ -1,7 +1,7 @@
-import { ProxiedTuple, ShaderCallNodeInternal, ShaderNodeFn, Struct } from 'three/src/nodes/TSL.js';
-import { NodeBuilder, Texture3DNode, TextureNode } from 'three/webgpu';
+import { ProxiedTuple, ShaderCallNodeInternal, ShaderNodeFn } from 'three/src/nodes/TSL.js';
+import { NodeBuilder } from 'three/webgpu';
 import { Node, NodeType } from './node';
-type FnLayoutType = NodeType | Struct | 'texture' | 'texture3D';
+type FnLayoutType = NodeType | (new (...args: any[]) => any) | ((...args: any[]) => any);
 export interface FnLayoutInput<T extends FnLayoutType = FnLayoutType> {
     name: string;
     type: T;
@@ -12,7 +12,7 @@ export interface FnLayout<T extends FnLayoutType, Inputs extends readonly FnLayo
     type: T;
     inputs?: Inputs;
 }
-type InferNodeObject<T extends FnLayoutType> = T extends NodeType ? Node<T> : T extends Struct ? ReturnType<T> : T extends 'texture' ? TextureNode : T extends 'texture3D' ? Texture3DNode : never;
+type InferNodeObject<T extends FnLayoutType> = T extends NodeType ? Node<T> : T extends new (...args: any[]) => any ? InstanceType<T> : T extends (...args: any[]) => any ? ReturnType<T> : never;
 type InferNodeObjects<Inputs extends readonly FnLayoutInput[]> = {
     [K in keyof Inputs]: Inputs[K] extends FnLayoutInput<infer T> ? InferNodeObject<T> : never;
 };

package/types/webgpu/LensGlareNode.d.ts

@@ -10,7 +10,7 @@ export declare class LensGlareNode extends FilterNode {
     sizeScale: import('three/webgpu').UniformNode<Vector2>;
     luminanceThreshold: import('three/webgpu').UniformNode<number>;
     private computeNode?;
-    private readonly counterBuffer;
+    private readonly indirectBuffer;
     private instanceBuffer;
     private readonly renderTarget;
     private readonly material;

package/types/webgpu/STBNTextureNode.d.ts

@@ -0,0 +1,9 @@
+import { Texture3DNode, NodeBuilder } from 'three/webgpu';
+export declare class STBNTextureNode extends Texture3DNode {
+    url: string;
+    constructor();
+    customCacheKey(): number;
+    setup(builder: NodeBuilder): unknown;
+}
+export declare const stbnTexture: STBNTextureNode;
+export declare const stbn: import('three/src/nodes/TSL.js').ShaderCallNodeInternal;

package/types/webgpu/ScreenSpaceShadowNode.d.ts

@@ -14,21 +14,19 @@ export declare class ScreenSpaceShadowNode extends TempNode {
     shadowContrast: import('three/webgpu').UniformNode<number>;
     shadowIntensity: import('three/webgpu').UniformNode<number>;
     bilinearThreshold: import('three/webgpu').UniformNode<number>;
-    nearDepth: import('three/webgpu').UniformNode<number>;
-    farDepth: import('three/webgpu').UniformNode<number>;
     private readonly lightCoordinate;
     private readonly dispatchOffset;
     private readonly dispatchIndex;
     private readonly dispatches;
     private dispatchCount;
-    private computeNode?;
+    private readonly computeNode;
     constructor(depthNode: TextureNode, camera: Camera, mainLight: DirectionalLight);
     customCacheKey(): number;
     getTextureNode(): TextureNode;
     setSize(width: number, height: number): this;
     updateBefore(frame: NodeFrame): void;
     private updateDispatchList;
-    private setupCompute;
+    private createComputeNode;
     setup(builder: NodeBuilder): unknown;
     dispose(): void;
 }

package/types/webgpu/SeparableFilterNode.d.ts

@@ -1,4 +1,3 @@
-import { Vector2 } from 'three';
 import { NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 import { FilterNode } from './FilterNode';
 import { Node } from './node';
@@ -9,8 +8,8 @@ export declare abstract class SeparableFilterNode extends FilterNode {
     private readonly material;
     private readonly mesh;
     private rendererState?;
-    protected readonly inputTexelSize: import('three/webgpu').UniformNode<Vector2>;
-    protected readonly direction: import('three/webgpu').UniformNode<Vector2>;
+    protected readonly inputTexelSize: import('three/webgpu').UniformNode<import('three').Vector2>;
+    protected readonly direction: import('three/webgpu').UniformNode<import('three').Vector2>;
     constructor(inputNode?: TextureNode | null);
     setSize(width: number, height: number): this;
     updateBefore({ renderer }: NodeFrame): void;

package/types/webgpu/SingleFilterNode.d.ts

@@ -1,4 +1,3 @@
-import { Vector2 } from 'three';
 import { NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 import { FilterNode } from './FilterNode';
 import { Node } from './node';
@@ -7,7 +6,7 @@ export declare abstract class SingleFilterNode extends FilterNode {
     private readonly material;
     private readonly mesh;
     private rendererState?;
-    protected readonly inputTexelSize: import('three/webgpu').UniformNode<Vector2>;
+    protected readonly inputTexelSize: import('three/webgpu').UniformNode<import('three').Vector2>;
     constructor(inputNode?: TextureNode | null);
     setSize(width: number, height: number): this;
     updateBefore({ renderer }: NodeFrame): void;

package/types/webgpu/StorageTexture3DNode.d.ts

@@ -0,0 +1,9 @@
+import { StorageTextureNode, Node, NodeBuilder } from 'three/webgpu';
+export declare class StorageTexture3DNode extends StorageTextureNode {
+    static get type(): string;
+    getDefaultUV(): Node;
+    setUpdateMatrix(_value: boolean): void;
+    generateUV(builder: NodeBuilder, uvNode: Node): string;
+    generateOffset(builder: NodeBuilder, offsetNode: Node): string;
+}
+export declare const storageTexture3D: (...args: ConstructorParameters<typeof StorageTexture3DNode>) => StorageTexture3DNode;

package/types/webgpu/TemporalAntialiasNode.d.ts

@@ -24,7 +24,7 @@ export declare class TemporalAntialiasNode extends TempNode {
     private readonly resolveMaterial;
     private readonly mesh;
     private rendererState?;
-    private needsSyncPostProcessing;
+    private needsSyncRenderPipeline;
     private needsClearHistory;
     private readonly resolveNode;
     private readonly historyNode;

package/types/webgpu/accessors.d.ts

@@ -1,10 +1,11 @@
-import { Vector3, Camera } from 'three';
+import { Camera, Vector3 } from 'three';
 import { UniformNode } from 'three/webgpu';
 import { Node } from './node';
-export declare const projectionMatrix: (camera: Camera) => Node<"mat4">;
-export declare const viewMatrix: (camera: Camera) => Node<"mat4">;
-export declare const inverseProjectionMatrix: (camera: Camera) => Node<"mat4">;
-export declare const inverseViewMatrix: (camera: Camera) => Node<"mat4">;
-export declare const cameraPositionWorld: (camera: Camera) => UniformNode<Vector3>;
-export declare const cameraNear: (camera: Camera) => Node<"float">;
-export declare const cameraFar: (camera: Camera) => Node<"float">;
+export declare const projectionMatrix: (camera?: Camera | null) => Node<"mat4">;
+export declare const viewMatrix: (camera?: Camera | null) => Node<"mat4">;
+export declare const inverseProjectionMatrix: (camera?: Camera | null) => Node<"mat4">;
+export declare const inverseViewMatrix: (camera?: Camera | null) => Node<"mat4">;
+export declare const cameraPositionWorld: (camera?: Camera | null) => UniformNode<Vector3>;
+export declare const cameraNear: (camera?: Camera | null) => Node<"float">;
+export declare const cameraFar: (camera?: Camera | null) => Node<"float">;
+export declare const viewZ: import('three/webgpu').VarNode;

package/types/webgpu/debug.d.ts

@@ -1,7 +1,8 @@
 import { NodeMaterial, Node, Renderer } from 'three/webgpu';
-export declare function debugFragmentNode(renderer: Renderer, material: NodeMaterial): void;
-export declare function debugVertexNode(renderer: Renderer, material: NodeMaterial): void;
-export declare function debugNode(renderer: Renderer, node: Node): void;
+export declare function debugMaterial(renderer: Renderer, material: NodeMaterial): Promise<string | null>;
+export declare function debugVertexNode(renderer: Renderer, material: NodeMaterial): Promise<string | null>;
+export declare function debugFragmentNode(renderer: Renderer, material: NodeMaterial): Promise<string | null>;
+export declare function debugNode(renderer: Renderer, node: Node): Promise<string | null>;
 export declare function hookFunction<T, K extends keyof {
     [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: unknown;
 }, Args extends unknown[] = T[K] extends (...args: any[]) => any ? Parameters<T[K]> : never, Result = T[K] extends (...args: any[]) => any ? ReturnType<T[K]> : never>(target: T, name: K, callback: (...args: Args) => void): T;

package/types/webgpu/events.d.ts

@@ -0,0 +1,3 @@
+import { Node, NodeFrame } from 'three/webgpu';
+export declare const OnFrameUpdate: (callback: (frame: NodeFrame) => void) => Node;
+export declare const OnBeforeFrameUpdate: (callback: (frame: NodeFrame) => void) => Node;

package/types/webgpu/index.d.ts

@@ -1,6 +1,8 @@
 export * from './accessors';
+export * from './CascadedShadowMapsNode';
 export * from './debug';
 export * from './DownsampleThresholdNode';
+export * from './events';
 export * from './FnLayout';
 export * from './FnVar';
 export * from './GaussianBlurNode';
@@ -16,6 +18,8 @@ export * from './OutputTexture3DNode';
 export * from './OutputTextureNode';
 export * from './sampling';
 export * from './ScreenSpaceShadowNode';
+export * from './STBNTextureNode';
+export * from './StorageTexture3DNode';
 export * from './TemporalAntialiasNode';
 export * from './transformations';
 export * from './utils';

package/types/webgpu/math.d.ts

@@ -1,3 +1,6 @@
+export declare const bvecNot: (...params: import('three/webgpu').Node[]) => import('three/webgpu').FunctionOverloadingNode;
+export declare const bvecAnd: (...params: import('three/webgpu').Node[]) => import('three/webgpu').FunctionOverloadingNode;
+export declare const bvecOr: (...params: import('three/webgpu').Node[]) => import('three/webgpu').FunctionOverloadingNode;
 export declare const raySphereIntersection: import('three/src/nodes/TSL.js').ShaderNodeFn<[rayOrigin: number | import('three/webgpu').Node, rayDirection: number | import('three/webgpu').Node, center: number | import('three/webgpu').Node, radius: number | import('three/webgpu').Node]>;
 export declare const raySpheresIntersectionsStruct: import('three/src/nodes/TSL.js').Struct;
 export declare const raySpheresIntersections: import('three/src/nodes/TSL.js').ShaderNodeFn<[rayOrigin: number | import('three/webgpu').Node, rayDirection: number | import('three/webgpu').Node, center: number | import('three/webgpu').Node, radii: number | import('three/webgpu').Node]>;

package/types/webgpu/sampling.d.ts

@@ -1 +1,2 @@
-export declare const textureCatmullRom: import('three/src/nodes/TSL.js').ShaderNodeFn<[textureNode: number | import('three/webgpu').Node, uv: number | import('three/webgpu').Node]>;
+export declare const textureGather: import('three/src/nodes/TSL.js').ShaderNodeFn<[textureNode: number | import('three/webgpu').Node, uvNode: number | import('three/webgpu').Node, component?: unknown]>;
+export declare const textureCatmullRom: import('three/src/nodes/TSL.js').ShaderNodeFn<[textureNode: number | import('three/webgpu').Node, uvNode?: number | import('three/webgpu').Node | undefined]>;

package/types/webgpu/transformations.d.ts

@@ -1,12 +1,9 @@
+import { Camera } from 'three';
 import { Node } from './node';
-export interface DepthOptions {
-    perspective?: boolean;
-    logarithmic?: boolean;
-}
-export declare const depthToViewZ: (depth: Node<"float">, near: Node<"float">, far: Node<"float">, { perspective, logarithmic }?: DepthOptions) => Node<"float">;
-export declare const logarithmicToPerspectiveDepth: (depth: Node<"float">, near: Node<"float">, far: Node<"float">) => Node<"float">;
-export declare const perspectiveToLogarithmicDepth: (depth: Node<"float">, near: Node<"float">, far: Node<"float">) => Node<"float">;
+export declare const depthToViewZ: import('three/src/nodes/TSL.js').ShaderNodeFn<[depth: number | import('three/webgpu').Node, camera?: Camera | null | undefined, near?: number | import('three/webgpu').Node | null | undefined, far?: number | import('three/webgpu').Node | null | undefined]>;
+export declare const logarithmicToPerspectiveDepth: (depth: Node<"float">, near?: Node<"float"> | null, far?: Node<"float"> | null) => Node<"float">;
+export declare const perspectiveToLogarithmicDepth: (depth: Node<"float">, near?: Node<"float"> | null, far?: Node<"float"> | null) => Node<"float">;
 export declare const screenToPositionView: (uv: Node<"vec2">, depth: Node<"float">, viewZ: Node<"float">, projectionMatrix: Node<"mat4">, inverseProjectionMatrix: Node<"mat4">) => Node<"vec3">;
-export declare const turbo: (x: Node<"float">) => Node<"vec3">;
-export declare const depthToColor: (depth: Node<"float">, near: Node<"float">, far: Node<"float">, options?: DepthOptions) => Node<"vec3">;
-export declare const equirectToDirectionWorld: (uv: Node<"vec2">) => Node<"vec3">;
+export declare const turbo: import('three/src/nodes/TSL.js').ShaderNodeFn<[number | import('three/webgpu').Node]>;
+export declare const depthToColor: import('three/src/nodes/TSL.js').ShaderNodeFn<[depth: number | import('three/webgpu').Node, camera?: Camera | undefined, near?: number | import('three/webgpu').Node | undefined, far?: number | import('three/webgpu').Node | undefined]>;
+export declare const equirectToDirectionWorld: import('three/src/nodes/TSL.js').ShaderNodeFn<[number | import('three/webgpu').Node]>;