@takram/three-geospatial 0.7.1 → 0.9.0

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

@@ -9,6 +9,7 @@ export declare class HighpVelocityNode extends TempNode {
     private readonly previousModelViewMatrix;
     private readonly objectModelViewMatrices;
     constructor();
+    setProjectionMatrix(value: Matrix4 | null): this;
     update({ camera }: NodeFrame): void;
     updateBefore({ object, camera }: NodeFrame): void;
     updateAfter({ object }: NodeFrame): void;

package/types/webgpu/LensFlareNode.d.ts

@@ -1,4 +1,4 @@
-import { TempNode, NodeBuilder, TextureNode } from 'three/webgpu';
+import { TempNode, NodeBuilder, RTTNode, TextureNode } from 'three/webgpu';
 import { DownsampleThresholdNode } from './DownsampleThresholdNode';
 import { GaussianBlurNode } from './GaussianBlurNode';
 import { LensGhostNode } from './LensGhostNode';
@@ -6,7 +6,6 @@ import { LensGlareNode } from './LensGlareNode';
 import { LensHaloNode } from './LensHaloNode';
 import { MipmapSurfaceBlurNode } from './MipmapSurfaceBlurNode';
 import { Node } from './node';
-import { RTTextureNode } from './RTTextureNode';
 export declare class LensFlareNode extends TempNode {
     static get type(): string;
     inputNode?: TextureNode | null;
@@ -17,7 +16,7 @@ export declare class LensFlareNode extends TempNode {
     bloomNode: MipmapSurfaceBlurNode;
     glareNode: LensGlareNode;
     bloomIntensity: import('three/webgpu').UniformNode<number>;
-    featuresNode: RTTextureNode;
+    featuresNode: RTTNode;
     constructor(inputNode?: TextureNode | null);
     setup(builder: NodeBuilder): unknown;
     dispose(): void;

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

@@ -0,0 +1,33 @@
+import { Camera, DirectionalLight } from 'three';
+import { StorageTexture, TempNode, NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
+export declare class ScreenSpaceShadowNode extends TempNode {
+    get type(): string;
+    depthNode: TextureNode;
+    camera: Camera;
+    mainLight: DirectionalLight;
+    sampleCount: number;
+    hardShadowSamples: number;
+    fadeOutSamples: number;
+    readonly outputTexture: StorageTexture;
+    private readonly textureNode;
+    thickness: import('three/webgpu').UniformNode<number>;
+    shadowContrast: import('three/webgpu').UniformNode<number>;
+    shadowIntensity: import('three/webgpu').UniformNode<number>;
+    bilinearThreshold: import('three/webgpu').UniformNode<number>;
+    private readonly lightCoordinate;
+    private readonly dispatchOffset;
+    private readonly dispatchIndex;
+    private readonly dispatches;
+    private dispatchCount;
+    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 createComputeNode;
+    setup(builder: NodeBuilder): unknown;
+    dispose(): void;
+}
+export declare const screenSpaceShadow: (...args: ConstructorParameters<typeof ScreenSpaceShadowNode>) => ScreenSpaceShadowNode;

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

@@ -1,9 +1,6 @@
-import { Matrix4, Camera } from 'three';
+import { Camera } from 'three';
 import { TempNode, NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 import { Node } from './node';
-interface VelocityNodeImmutable {
-    projectionMatrix?: Matrix4 | null;
-}
 interface SupportedCamera extends Camera {
     updateProjectionMatrix(): void;
     setViewOffset(fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number): void;
@@ -11,7 +8,6 @@ interface SupportedCamera extends Camera {
 }
 export declare class TemporalAntialiasNode extends TempNode {
     static get type(): string;
-    private readonly velocityNodeImmutable;
     inputNode: TextureNode;
     depthNode: TextureNode;
     velocityNode: TextureNode;
@@ -26,21 +22,19 @@ export declare class TemporalAntialiasNode extends TempNode {
     private historyRT;
     private previousDepthTexture?;
     private readonly resolveMaterial;
-    private readonly copyMaterial;
     private readonly mesh;
     private rendererState?;
-    private needsSyncPostProcessing;
+    private needsSyncRenderPipeline;
     private needsClearHistory;
     private readonly resolveNode;
     private readonly historyNode;
     private readonly previousDepthNode;
     private readonly originalProjectionMatrix;
     private jitterIndex;
-    constructor(velocityNodeImmutable: VelocityNodeImmutable, inputNode: TextureNode, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera);
+    constructor(inputNode: TextureNode, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera);
     customCacheKey(): number;
     private createRenderTarget;
     getTextureNode(): TextureNode;
-    private setProjectionMatrix;
     setSize(width: number, height: number): this;
     private clearHistory;
     private setViewOffset;
@@ -52,5 +46,10 @@ export declare class TemporalAntialiasNode extends TempNode {
     setup(builder: NodeBuilder): unknown;
     dispose(): void;
 }
-export declare const temporalAntialias: (velocityNodeImmutable: VelocityNodeImmutable) => (inputNode: Node, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera) => TemporalAntialiasNode;
+/**
+ * @deprecated Function signature has been changed. Use
+ *   temporalAntialias(inputNode, depthNode, velocityNode, camera)
+ */
+export declare function temporalAntialias(velocityNodeImmutable: unknown): (inputNode: Node, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera) => TemporalAntialiasNode;
+export declare function temporalAntialias(inputNode: Node, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera): TemporalAntialiasNode;
 export {};

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';
@@ -14,8 +16,10 @@ export * from './MipmapSurfaceBlurNode';
 export * from './node';
 export * from './OutputTexture3DNode';
 export * from './OutputTextureNode';
-export * from './RTTextureNode';
 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]>;

package/src/webgpu/RTTextureNode.ts

@@ -1,130 +0,0 @@
-import { uv } from 'three/tsl'
-import {
-  HalfFloatType,
-  LinearFilter,
-  NodeMaterial,
-  NodeUpdateType,
-  QuadMesh,
-  RendererUtils,
-  RenderTarget,
-  RGBAFormat,
-  TextureNode,
-  Vector2,
-  type Node,
-  type NodeBuilder,
-  type NodeFrame
-} from 'three/webgpu'
-
-const { resetRendererState, restoreRendererState } = RendererUtils
-
-function createRenderTarget(): RenderTarget {
-  const renderTarget = new RenderTarget(1, 1, {
-    depthBuffer: false,
-    type: HalfFloatType,
-    format: RGBAFormat
-  })
-  const texture = renderTarget.texture
-  texture.minFilter = LinearFilter
-  texture.magFilter = LinearFilter
-  texture.generateMipmaps = false
-  return renderTarget
-}
-
-const sizeScratch = /*#__PURE__*/ new Vector2()
-
-// Similar to RTTNode, which is a bit finicky to handle.
-export class RTTextureNode extends TextureNode {
-  static override get type(): string {
-    return 'RTTextureNode'
-  }
-
-  node: Node
-  resolutionScale = 1
-
-  private readonly renderTarget: RenderTarget
-  private readonly material = new NodeMaterial()
-  private readonly mesh = new QuadMesh(this.material)
-  private rendererState?: RendererUtils.RendererState
-
-  constructor(node: Node, uvNode?: Node) {
-    const renderTarget = createRenderTarget()
-    super(renderTarget.texture, uvNode ?? uv())
-    this.node = node
-    this.renderTarget = renderTarget
-    this.updateBeforeType = NodeUpdateType.FRAME
-  }
-
-  setSize(width: number, height: number): this {
-    const { resolutionScale } = this
-    const w = Math.max(Math.round(width * resolutionScale), 1)
-    const h = Math.max(Math.round(height * resolutionScale), 1)
-    this.renderTarget.setSize(w, h)
-    return this
-  }
-
-  override updateBefore({ renderer }: NodeFrame): void {
-    if (renderer == null) {
-      return
-    }
-
-    const size = renderer.getDrawingBufferSize(sizeScratch)
-    this.setSize(size.x, size.y)
-
-    this.rendererState = resetRendererState(renderer, this.rendererState)
-
-    renderer.setRenderTarget(this.renderTarget)
-    this.mesh.render(renderer)
-
-    restoreRendererState(renderer, this.rendererState)
-  }
-
-  override setup(builder: NodeBuilder): unknown {
-    const { material } = this
-    // I don't fully understand why, but updates on "node" doesn't propagate
-    // unless giving the builder context.
-    material.fragmentNode = this.node.context(builder.getContext())
-    material.needsUpdate = true
-    return super.setup(builder)
-  }
-
-  override dispose(): void {
-    this.renderTarget.dispose()
-    this.material.dispose()
-    this.mesh.geometry.dispose()
-    super.dispose()
-  }
-
-  // @ts-expect-error Ignore
-  override clone(): TextureNode {
-    const result = new TextureNode(this.value, this.uvNode, this.levelNode)
-    result.sampler = this.sampler
-    result.referenceNode = this
-    return result
-  }
-}
-
-export const rtTexture = (
-  ...args: ConstructorParameters<typeof RTTextureNode>
-): RTTextureNode => new RTTextureNode(...args)
-
-export const convertToTexture = (
-  node: Node & {
-    isTextureNode?: boolean
-    isSampleNode?: boolean
-    getTextureNode?: () => TextureNode
-  },
-  name?: string
-): TextureNode => {
-  let textureNode: TextureNode
-  if (node.isTextureNode === true || node.isSampleNode === true) {
-    textureNode = node as TextureNode
-  } else if (node.getTextureNode != null) {
-    textureNode = node.getTextureNode()
-  } else {
-    textureNode = new RTTextureNode(node)
-    if (name != null) {
-      textureNode.value.name = name
-    }
-  }
-  return textureNode
-}

package/types/webgpu/RTTextureNode.d.ts

@@ -1,22 +0,0 @@
-import { TextureNode, Node, NodeBuilder, NodeFrame } from 'three/webgpu';
-export declare class RTTextureNode extends TextureNode {
-    static get type(): string;
-    node: Node;
-    resolutionScale: number;
-    private readonly renderTarget;
-    private readonly material;
-    private readonly mesh;
-    private rendererState?;
-    constructor(node: Node, uvNode?: Node);
-    setSize(width: number, height: number): this;
-    updateBefore({ renderer }: NodeFrame): void;
-    setup(builder: NodeBuilder): unknown;
-    dispose(): void;
-    clone(): TextureNode;
-}
-export declare const rtTexture: (...args: ConstructorParameters<typeof RTTextureNode>) => RTTextureNode;
-export declare const convertToTexture: (node: Node & {
-    isTextureNode?: boolean;
-    isSampleNode?: boolean;
-    getTextureNode?: () => TextureNode;
-}, name?: string) => TextureNode;