@takram/three-geospatial 0.5.1 → 0.7.0

package/src/webgpu/transformations.ts

@@ -2,7 +2,6 @@ import {
   cos,
   int,
   logarithmicDepthToViewZ,
-  nodeObject,
   orthographicDepthToViewZ,
   perspectiveDepthToViewZ,
   PI,
@@ -15,7 +14,7 @@ import {
   viewZToPerspectiveDepth
 } from 'three/tsl'
 
-import type { Node, NodeObject } from './node'
+import type { Node } from './node'
 
 export interface DepthOptions {
   perspective?: boolean
@@ -24,44 +23,42 @@ export interface DepthOptions {
 
 export const depthToViewZ = (
   depth: Node<'float'>,
-  near: NodeObject<'float'>,
-  far: NodeObject<'float'>,
+  near: Node<'float'>,
+  far: Node<'float'>,
   { perspective = true, logarithmic = false }: DepthOptions = {}
-): NodeObject<'float'> => {
-  return (
-    logarithmic
-      ? logarithmicDepthToViewZ(depth, near, far)
-      : perspective
-        ? perspectiveDepthToViewZ(depth, near, far)
-        : orthographicDepthToViewZ(depth, near, far)
-  ) as NodeObject<'float'>
+): Node<'float'> => {
+  return logarithmic
+    ? logarithmicDepthToViewZ(depth, near, far)
+    : perspective
+      ? perspectiveDepthToViewZ(depth, near, far)
+      : orthographicDepthToViewZ(depth, near, far)
 }
 
 export const logarithmicToPerspectiveDepth = (
   depth: Node<'float'>,
-  near: NodeObject<'float'>,
-  far: NodeObject<'float'>
-): NodeObject<'float'> => {
+  near: Node<'float'>,
+  far: Node<'float'>
+): Node<'float'> => {
   const viewZ = logarithmicDepthToViewZ(depth, near, far)
-  return viewZToPerspectiveDepth(viewZ, near, far) as NodeObject<'float'>
+  return viewZToPerspectiveDepth(viewZ, near, far)
 }
 
 export const perspectiveToLogarithmicDepth = (
   depth: Node<'float'>,
-  near: NodeObject<'float'>,
-  far: NodeObject<'float'>
-): NodeObject<'float'> => {
-  const viewZ = nodeObject(perspectiveDepthToViewZ(depth, near, far))
-  return viewZToLogarithmicDepth(viewZ, near, far) as NodeObject<'float'>
+  near: Node<'float'>,
+  far: Node<'float'>
+): Node<'float'> => {
+  const viewZ = perspectiveDepthToViewZ(depth, near, far)
+  return viewZToLogarithmicDepth(viewZ, near, far)
 }
 
 export const screenToPositionView = (
-  uv: NodeObject<'vec2'>,
+  uv: Node<'vec2'>,
   depth: Node<'float'>,
-  viewZ: NodeObject<'float'>,
-  projectionMatrix: NodeObject<'mat4'>,
-  inverseProjectionMatrix: NodeObject<'mat4'>
-): NodeObject<'vec3'> => {
+  viewZ: Node<'float'>,
+  projectionMatrix: Node<'mat4'>,
+  inverseProjectionMatrix: Node<'mat4'>
+): Node<'vec3'> => {
   const scale = projectionMatrix.element(int(2)).element(int(3))
   const offset = projectionMatrix.element(int(3)).element(int(3))
   const clip = vec4(vec3(uv.flipY(), depth).mul(2).sub(1), 1)
@@ -80,25 +77,23 @@ const turboCoeffs = [
   /*#__PURE__*/ vec3(0.1357, 0.0914, 0.1067)
 ]
 
-export const turbo = (x: NodeObject<'float'>): NodeObject<'vec3'> => {
+export const turbo = (x: Node<'float'>): Node<'vec3'> => {
   return turboCoeffs
     .slice(1)
-    .reduce<NodeObject>((y, offset) => offset.add(x.mul(y)), turboCoeffs[0])
+    .reduce<Node>((y, offset) => offset.add(x.mul(y)), turboCoeffs[0])
 }
 
 export const depthToColor = (
   depth: Node<'float'>,
-  near: NodeObject<'float'>,
-  far: NodeObject<'float'>,
+  near: Node<'float'>,
+  far: Node<'float'>,
   options?: DepthOptions
-): NodeObject<'vec3'> => {
+): Node<'vec3'> => {
   const viewZ = depthToViewZ(depth, near, far, options)
-  return turbo(viewZToLogarithmicDepth(viewZ, near, far) as NodeObject<'float'>)
+  return turbo(viewZToLogarithmicDepth(viewZ, near, far))
 }
 
-export const equirectToDirectionWorld = (
-  uv: NodeObject<'vec2'>
-): NodeObject<'vec3'> => {
+export const equirectToDirectionWorld = (uv: Node<'vec2'>): Node<'vec3'> => {
   const lambda = sub(0.5, uv.x).mul(PI2)
   const phi = sub(uv.y, 0.5).mul(PI)
   const cosPhi = cos(phi)

package/src/webgpu/utils.ts

@@ -1,13 +1,13 @@
-import type Backend from 'three/src/renderers/common/Backend.js'
 import { NodeBuilder, type Renderer } from 'three/webgpu'
 
-import { reinterpretType } from '../types'
-
-export function isWebGPU(target: NodeBuilder | Renderer | Backend): boolean {
-  const renderer = target instanceof NodeBuilder ? target.renderer : target
-  const backend = 'backend' in renderer ? renderer.backend : target
-  // WORKAROUND: The type of Backend cannot be augmented because it is
-  // default-exported.
-  reinterpretType<Backend & { isWebGPUBackend?: boolean }>(backend)
+export function isWebGPU(
+  target: NodeBuilder | Renderer | Renderer['backend']
+): boolean {
+  const backend =
+    target instanceof NodeBuilder
+      ? target.renderer.backend
+      : 'backend' in target
+        ? target.backend
+        : target
   return backend.isWebGPUBackend === true
 }

package/types/decorators.d.ts

@@ -1,9 +1,9 @@
 interface MaterialLike {
-    defines?: Record<string, string>;
+    defines?: Record<string, unknown>;
     set needsUpdate(value: boolean);
 }
 interface EffectLike {
-    defines: Map<string, string>;
+    defines: Map<string, unknown>;
 }
 export declare function define(name: string): <T extends MaterialLike | EffectLike, K extends keyof T>(target: T[K] extends boolean ? T : never, propertyKey: K) => void;
 export interface DefineIntDecoratorOptions {

package/types/webgpu/DownsampleThresholdNode.d.ts

@@ -1,11 +1,11 @@
 import { TextureNode } from 'three/webgpu';
-import { Node, NodeObject } from './node';
+import { Node } from './node';
 import { SingleFilterNode } from './SingleFilterNode';
 export declare class DownsampleThresholdNode extends SingleFilterNode {
     static get type(): string;
-    thresholdLevel: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
-    thresholdRange: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
+    thresholdLevel: import('three/webgpu').UniformNode<number>;
+    thresholdRange: import('three/webgpu').UniformNode<number>;
     constructor(inputNode?: TextureNode | null);
     protected setupOutputNode(): Node;
 }
-export declare const downsampleThreshold: (...args: ConstructorParameters<typeof DownsampleThresholdNode>) => NodeObject<DownsampleThresholdNode>;
+export declare const downsampleThreshold: (...args: ConstructorParameters<typeof DownsampleThresholdNode>) => DownsampleThresholdNode;

package/types/webgpu/DualMipmapFilterNode.d.ts

@@ -9,8 +9,8 @@ export declare abstract class DualMipmapFilterNode extends FilterNode {
     private readonly upsampleMaterial;
     private readonly mesh;
     private rendererState?;
-    protected readonly inputTexelSize: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<Vector2>>;
-    protected readonly downsampleNode: import('three/tsl').ShaderNodeObject<TextureNode>;
+    protected readonly inputTexelSize: import('three/webgpu').UniformNode<Vector2>;
+    protected readonly downsampleNode: TextureNode;
     constructor(inputNode: TextureNode | null | undefined, levels: number);
     setSize(width: number, height: number): this;
     updateBefore({ renderer }: NodeFrame): void;

package/types/webgpu/FnLayout.d.ts

@@ -1,6 +1,6 @@
 import { ProxiedTuple, ShaderCallNodeInternal, ShaderNodeFn, Struct } from 'three/src/nodes/TSL.js';
 import { NodeBuilder, Texture3DNode, TextureNode } from 'three/webgpu';
-import { NodeObject, NodeType } from './node';
+import { Node, NodeType } from './node';
 type FnLayoutType = NodeType | Struct | 'texture' | 'texture3D';
 export interface FnLayoutInput<T extends FnLayoutType = FnLayoutType> {
     name: string;
@@ -12,10 +12,10 @@ export interface FnLayout<T extends FnLayoutType, Inputs extends readonly FnLayo
     type: T;
     inputs?: Inputs;
 }
-type InferNodeObject<T extends FnLayoutType> = T extends NodeType ? NodeObject<T> : T extends Struct ? ReturnType<T> : T extends 'texture' ? NodeObject<TextureNode> : T extends 'texture3D' ? NodeObject<Texture3DNode> : never;
+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 InferNodeObjects<Inputs extends readonly FnLayoutInput[]> = {
     [K in keyof Inputs]: Inputs[K] extends FnLayoutInput<infer T> ? InferNodeObject<T> : never;
 };
-export type FnLayoutResult<T extends FnLayoutType, Inputs extends readonly FnLayoutInput[], Nodes extends readonly unknown[] = InferNodeObjects<Inputs>> = (callback: (...args: [] extends Nodes ? [NodeBuilder] : [Nodes, NodeBuilder]) => InferNodeObject<T> | NodeObject<ShaderCallNodeInternal>) => ShaderNodeFn<ProxiedTuple<Nodes>>;
+export type FnLayoutResult<T extends FnLayoutType, Inputs extends readonly FnLayoutInput[], Nodes extends readonly unknown[] = InferNodeObjects<Inputs>> = (callback: (...args: [] extends Nodes ? [NodeBuilder] : [Nodes, NodeBuilder]) => InferNodeObject<T> | ShaderCallNodeInternal) => ShaderNodeFn<ProxiedTuple<Nodes>>;
 export declare function FnLayout<T extends FnLayoutType, const Inputs extends readonly FnLayoutInput[] = []>({ typeOnly, ...layout }: FnLayout<T, Inputs>): FnLayoutResult<T, Inputs>;
 export {};

package/types/webgpu/GaussianBlurNode.d.ts

@@ -1,5 +1,5 @@
 import { NodeBuilder, TextureNode } from 'three/webgpu';
-import { Node, NodeObject } from './node';
+import { Node } from './node';
 import { SeparableFilterNode } from './SeparableFilterNode';
 export declare class GaussianBlurNode extends SeparableFilterNode {
     static get type(): string;
@@ -7,4 +7,4 @@ export declare class GaussianBlurNode extends SeparableFilterNode {
     constructor(inputNode?: TextureNode | null, kernelSize?: number);
     protected setupOutputNode(builder: NodeBuilder): Node;
 }
-export declare const gaussianBlur: (...args: ConstructorParameters<typeof GaussianBlurNode>) => NodeObject<GaussianBlurNode>;
+export declare const gaussianBlur: (...args: ConstructorParameters<typeof GaussianBlurNode>) => GaussianBlurNode;

package/types/webgpu/HighpVelocityNode.d.ts

@@ -1,6 +1,5 @@
 import { Matrix4 } from 'three';
-import { NodeFrame } from 'three/src/Three.WebGPU.js';
-import { TempNode, NodeBuilder } from 'three/webgpu';
+import { TempNode, NodeBuilder, NodeFrame } from 'three/webgpu';
 export declare class HighpVelocityNode extends TempNode {
     static get type(): string;
     projectionMatrix?: Matrix4 | null;
@@ -15,4 +14,4 @@ export declare class HighpVelocityNode extends TempNode {
     updateAfter({ object }: NodeFrame): void;
     setup(builder: NodeBuilder): unknown;
 }
-export declare const highpVelocity: import('three/tsl').ShaderNodeObject<HighpVelocityNode>;
+export declare const highpVelocity: HighpVelocityNode;

package/types/webgpu/KawaseBlurNode.d.ts

@@ -1,10 +1,10 @@
 import { NodeBuilder, TextureNode } from 'three/webgpu';
 import { DualMipmapFilterNode } from './DualMipmapFilterNode';
-import { Node, NodeObject } from './node';
+import { Node } from './node';
 export declare class KawaseBlurNode extends DualMipmapFilterNode {
     static get type(): string;
     constructor(inputNode?: TextureNode | null, levels?: number);
     protected setupDownsampleNode(builder: NodeBuilder): Node;
     protected setupUpsampleNode(builder: NodeBuilder): Node;
 }
-export declare const kawaseBlur: (...args: ConstructorParameters<typeof KawaseBlurNode>) => NodeObject<KawaseBlurNode>;
+export declare const kawaseBlur: (...args: ConstructorParameters<typeof KawaseBlurNode>) => KawaseBlurNode;

package/types/webgpu/LensFlareNode.d.ts

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

package/types/webgpu/LensGhostNode.d.ts

@@ -2,7 +2,7 @@ import { TempNode, NodeBuilder, TextureNode } from 'three/webgpu';
 export declare class LensGhostNode extends TempNode {
     static get type(): string;
     inputNode?: TextureNode | null;
-    intensity: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
+    intensity: import('three/webgpu').UniformNode<number>;
     constructor(inputNode?: TextureNode | null);
     setup(builder: NodeBuilder): unknown;
 }

package/types/webgpu/LensGlareNode.d.ts

@@ -1,14 +1,14 @@
 import { Vector2 } from 'three';
 import { NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 import { FilterNode } from './FilterNode';
-import { Node, NodeObject } from './node';
+import { Node } from './node';
 export declare class LensGlareNode extends FilterNode {
     spikeNode?: TextureNode | null;
     spikePairCount: number;
     wireframe: boolean;
-    intensity: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
-    sizeScale: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<Vector2>>;
-    luminanceThreshold: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
+    intensity: import('three/webgpu').UniformNode<number>;
+    sizeScale: import('three/webgpu').UniformNode<Vector2>;
+    luminanceThreshold: import('three/webgpu').UniformNode<number>;
     private computeNode?;
     private readonly counterBuffer;
     private instanceBuffer;
@@ -29,4 +29,4 @@ export declare class LensGlareNode extends FilterNode {
     setup(builder: NodeBuilder): unknown;
     dispose(): void;
 }
-export declare const lensGlare: (inputNode: Node | null) => NodeObject<LensGlareNode>;
+export declare const lensGlare: (inputNode: Node | null) => LensGlareNode;

package/types/webgpu/LensHaloNode.d.ts

@@ -2,8 +2,8 @@ import { TempNode, NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 export declare class LensHaloNode extends TempNode {
     static get type(): string;
     inputNode?: TextureNode | null;
-    intensity: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
-    chromaticAberration: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
+    intensity: import('three/webgpu').UniformNode<number>;
+    chromaticAberration: import('three/webgpu').UniformNode<number>;
     private readonly aspectRatio;
     constructor(inputNode?: TextureNode | null);
     updateBefore({ renderer }: NodeFrame): void;

package/types/webgpu/MipmapBlurNode.d.ts

@@ -1,12 +1,12 @@
 import { NodeBuilder, TextureNode, UniformNode, Vector2 } from 'three/webgpu';
 import { DualMipmapFilterNode } from './DualMipmapFilterNode';
-import { Node, NodeObject } from './node';
-export declare const mipmapBlurDownsample: (inputNode: TextureNode, texelSize: NodeObject<"vec2"> | NodeObject<UniformNode<Vector2>>) => NodeObject<"vec4">;
-export declare const mipmapBlurUpsample: (inputNode: TextureNode, texelSize: NodeObject<"vec2"> | NodeObject<UniformNode<Vector2>>) => NodeObject<"vec4">;
+import { Node } from './node';
+export declare const mipmapBlurDownsample: (inputNode: TextureNode, texelSize: Node<"vec2"> | UniformNode<Vector2>) => Node<"vec4">;
+export declare const mipmapBlurUpsample: (inputNode: TextureNode, texelSize: Node<"vec2"> | UniformNode<Vector2>) => Node<"vec4">;
 export declare class MipmapBlurNode extends DualMipmapFilterNode {
     static get type(): string;
     constructor(inputNode?: TextureNode | null, levels?: number);
     protected setupDownsampleNode(builder: NodeBuilder): Node;
     protected setupUpsampleNode(builder: NodeBuilder): Node;
 }
-export declare const mipmapBlur: (...args: ConstructorParameters<typeof MipmapBlurNode>) => NodeObject<MipmapBlurNode>;
+export declare const mipmapBlur: (...args: ConstructorParameters<typeof MipmapBlurNode>) => MipmapBlurNode;

package/types/webgpu/MipmapSurfaceBlurNode.d.ts

@@ -1,11 +1,11 @@
 import { NodeBuilder, TextureNode } from 'three/webgpu';
 import { DualMipmapFilterNode } from './DualMipmapFilterNode';
-import { Node, NodeObject } from './node';
+import { Node } from './node';
 export declare class MipmapSurfaceBlurNode extends DualMipmapFilterNode {
     static get type(): string;
-    blendAmount: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
+    blendAmount: import('three/webgpu').UniformNode<number>;
     constructor(inputNode?: TextureNode | null, levels?: number);
     protected setupDownsampleNode(builder: NodeBuilder): Node;
     protected setupUpsampleNode(builder: NodeBuilder): Node;
 }
-export declare const mipmapSurfaceBlur: (...args: ConstructorParameters<typeof MipmapSurfaceBlurNode>) => NodeObject<MipmapSurfaceBlurNode>;
+export declare const mipmapSurfaceBlur: (...args: ConstructorParameters<typeof MipmapSurfaceBlurNode>) => MipmapSurfaceBlurNode;

package/types/webgpu/OutputTexture3DNode.d.ts

@@ -1,6 +1,5 @@
 import { Texture } from 'three';
 import { Texture3DNode, Node, NodeBuilder } from 'three/webgpu';
-import { NodeObject } from './node';
 export declare class OutputTexture3DNode extends Texture3DNode {
     static get type(): string;
     owner: Node;
@@ -8,4 +7,4 @@ export declare class OutputTexture3DNode extends Texture3DNode {
     setup(builder: NodeBuilder): unknown;
     clone(): this;
 }
-export declare const outputTexture3D: (...args: ConstructorParameters<typeof OutputTexture3DNode>) => NodeObject<OutputTexture3DNode>;
+export declare const outputTexture3D: (...args: ConstructorParameters<typeof OutputTexture3DNode>) => OutputTexture3DNode;

package/types/webgpu/OutputTextureNode.d.ts

@@ -1,6 +1,5 @@
 import { Texture } from 'three';
 import { TextureNode, Node, NodeBuilder } from 'three/webgpu';
-import { NodeObject } from './node';
 export declare class OutputTextureNode extends TextureNode {
     static get type(): string;
     owner: Node;
@@ -8,4 +7,4 @@ export declare class OutputTextureNode extends TextureNode {
     setup(builder: NodeBuilder): unknown;
     clone(): this;
 }
-export declare const outputTexture: (...args: ConstructorParameters<typeof OutputTextureNode>) => NodeObject<OutputTextureNode>;
+export declare const outputTexture: (...args: ConstructorParameters<typeof OutputTextureNode>) => OutputTextureNode;

package/types/webgpu/RTTextureNode.d.ts

@@ -1,5 +1,4 @@
 import { TextureNode, Node, NodeBuilder, NodeFrame } from 'three/webgpu';
-import { NodeObject } from './node';
 export declare class RTTextureNode extends TextureNode {
     static get type(): string;
     node: Node;
@@ -15,9 +14,9 @@ export declare class RTTextureNode extends TextureNode {
     dispose(): void;
     clone(): TextureNode;
 }
-export declare const rtTexture: (...args: ConstructorParameters<typeof RTTextureNode>) => NodeObject<RTTextureNode>;
+export declare const rtTexture: (...args: ConstructorParameters<typeof RTTextureNode>) => RTTextureNode;
 export declare const convertToTexture: (node: Node & {
     isTextureNode?: boolean;
     isSampleNode?: boolean;
     getTextureNode?: () => TextureNode;
-}, name?: string) => NodeObject<TextureNode>;
+}, name?: string) => TextureNode;

package/types/webgpu/SeparableFilterNode.d.ts

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

package/types/webgpu/SingleFilterNode.d.ts

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

package/types/webgpu/TemporalAntialiasNode.d.ts

@@ -1,6 +1,6 @@
 import { Matrix4, Camera } from 'three';
 import { TempNode, NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
-import { Node, NodeObject } from './node';
+import { Node } from './node';
 interface VelocityNodeImmutable {
     projectionMatrix?: Matrix4 | null;
 }
@@ -16,10 +16,10 @@ export declare class TemporalAntialiasNode extends TempNode {
     depthNode: TextureNode;
     velocityNode: TextureNode;
     camera: SupportedCamera;
-    temporalAlpha: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
-    varianceGamma: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
-    velocityThreshold: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
-    depthError: import('three/tsl').ShaderNodeObject<import('three/webgpu').UniformNode<number>>;
+    temporalAlpha: import('three/webgpu').UniformNode<number>;
+    varianceGamma: import('three/webgpu').UniformNode<number>;
+    velocityThreshold: import('three/webgpu').UniformNode<number>;
+    depthError: import('three/webgpu').UniformNode<number>;
     debugShowRejection: boolean;
     private readonly textureNode;
     private resolveRT;
@@ -52,5 +52,5 @@ 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) => NodeObject<TemporalAntialiasNode>;
+export declare const temporalAntialias: (velocityNodeImmutable: VelocityNodeImmutable) => (inputNode: Node, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera) => TemporalAntialiasNode;
 export {};

package/types/webgpu/accessors.d.ts

@@ -1,10 +1,10 @@
 import { Vector3, Camera } from 'three';
 import { UniformNode } from 'three/webgpu';
-import { NodeObject } from './node';
-export declare const projectionMatrix: (camera: Camera) => NodeObject<"mat4">;
-export declare const viewMatrix: (camera: Camera) => NodeObject<"mat4">;
-export declare const inverseProjectionMatrix: (camera: Camera) => NodeObject<"mat4">;
-export declare const inverseViewMatrix: (camera: Camera) => NodeObject<"mat4">;
-export declare const cameraPositionWorld: (camera: Camera) => NodeObject<UniformNode<Vector3>>;
-export declare const cameraNear: (camera: Camera) => NodeObject<"float">;
-export declare const cameraFar: (camera: Camera) => NodeObject<"float">;
+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">;

package/types/webgpu/generators.d.ts

@@ -1,4 +1,4 @@
-import { NodeObject } from './node';
-export declare const interleavedGradientNoise: (seed: NodeObject<"vec2">) => NodeObject<"float">;
-export declare const dithering: NodeObject<'vec3'>;
-export declare const equirectGrid: (direction: NodeObject<"vec3">, lineWidth: NodeObject<"float">, count?: NodeObject<"vec2">) => NodeObject<"float">;
+import { Node } from './node';
+export declare const interleavedGradientNoise: (seed: Node<"vec2">) => Node<"float">;
+export declare const dithering: Node<'vec3'>;
+export declare const equirectGrid: (direction: Node<"vec3">, lineWidth: Node<"float">, count?: Node<"vec2">) => Node<"float">;

package/types/webgpu/node.d.ts

@@ -1,5 +1,4 @@
 import { Color, Matrix2, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
-import { ShaderNodeObject } from 'three/tsl';
 import { Node as N } from 'three/webgpu';
 declare const nodes: {
     readonly float: import('three/src/nodes/TSL.js').NumberFunction;
@@ -9,15 +8,15 @@ declare const nodes: {
     readonly vec2: import('three/src/nodes/TSL.js').Vector2Function;
     readonly ivec2: import('three/src/nodes/TSL.js').Vector2Function;
     readonly uvec2: import('three/src/nodes/TSL.js').Vector2Function;
-    readonly bvec2: (node: N) => ShaderNodeObject<N>;
+    readonly bvec2: (node: N) => N;
     readonly vec3: import('three/src/nodes/TSL.js').Vector3Function;
     readonly ivec3: import('three/src/nodes/TSL.js').Vector3Function;
     readonly uvec3: import('three/src/nodes/TSL.js').Vector3Function;
-    readonly bvec3: (node: N) => ShaderNodeObject<N>;
+    readonly bvec3: (node: N) => N;
     readonly vec4: import('three/src/nodes/TSL.js').Vector4Function;
     readonly ivec4: import('three/src/nodes/TSL.js').Vector4Function;
     readonly uvec4: import('three/src/nodes/TSL.js').Vector4Function;
-    readonly bvec4: (node: N) => ShaderNodeObject<N>;
+    readonly bvec4: (node: N) => N;
     readonly mat2: import('three/src/nodes/TSL.js').Matrix2Function;
     readonly mat3: import('three/src/nodes/TSL.js').Matrix3Function;
     readonly mat4: import('three/src/nodes/TSL.js').Matrix4Function;
@@ -28,6 +27,6 @@ export type NodeValueType = number | boolean | Vector2 | Vector3 | Vector4 | Mat
 export type NodeTypeOf<T extends NodeValueType> = T extends number ? 'float' : T extends boolean ? 'bool' : T extends Vector2 ? 'vec2' : T extends Vector3 ? 'vec3' : T extends Vector4 ? 'vec4' : T extends Matrix2 ? 'mat2' : T extends Matrix3 ? 'mat3' : T extends Matrix4 ? 'mat4' : T extends Color ? 'color' : never;
 export type NodeValueTypeOf<T extends NodeType> = T extends 'float' | 'int' | 'uint' ? number : T extends 'bool' ? boolean : T extends 'vec2' | 'ivec2' | 'uvec2' | 'bvec2' ? Vector2 : T extends 'vec3' | 'ivec3' | 'uvec3' | 'bvec3' ? Vector3 : T extends 'vec4' | 'ivec4' | 'uvec4' | 'bvec4' ? Vector4 : T extends 'mat2' ? Matrix2 : T extends 'mat3' ? Matrix3 : T extends 'mat4' ? Matrix4 : T extends 'color' ? Color : never;
 export type Node<T extends NodeType = NodeType> = N;
-export type NodeObject<T extends NodeType | N = N> = ShaderNodeObject<T extends NodeType ? Node<T> : T>;
+export declare const Node: typeof N;
 export declare function node<T extends NodeType>(type: T): (typeof nodes)[T];
 export {};

package/types/webgpu/sampling.d.ts

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

package/types/webgpu/transformations.d.ts

@@ -1,12 +1,12 @@
-import { Node, NodeObject } from './node';
+import { Node } from './node';
 export interface DepthOptions {
     perspective?: boolean;
     logarithmic?: boolean;
 }
-export declare const depthToViewZ: (depth: Node<"float">, near: NodeObject<"float">, far: NodeObject<"float">, { perspective, logarithmic }?: DepthOptions) => NodeObject<"float">;
-export declare const logarithmicToPerspectiveDepth: (depth: Node<"float">, near: NodeObject<"float">, far: NodeObject<"float">) => NodeObject<"float">;
-export declare const perspectiveToLogarithmicDepth: (depth: Node<"float">, near: NodeObject<"float">, far: NodeObject<"float">) => NodeObject<"float">;
-export declare const screenToPositionView: (uv: NodeObject<"vec2">, depth: Node<"float">, viewZ: NodeObject<"float">, projectionMatrix: NodeObject<"mat4">, inverseProjectionMatrix: NodeObject<"mat4">) => NodeObject<"vec3">;
-export declare const turbo: (x: NodeObject<"float">) => NodeObject<"vec3">;
-export declare const depthToColor: (depth: Node<"float">, near: NodeObject<"float">, far: NodeObject<"float">, options?: DepthOptions) => NodeObject<"vec3">;
-export declare const equirectToDirectionWorld: (uv: NodeObject<"vec2">) => NodeObject<"vec3">;
+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 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">;

package/types/webgpu/utils.d.ts

@@ -1,3 +1,2 @@
-import { default as Backend } from 'three/src/renderers/common/Backend.js';
 import { NodeBuilder, Renderer } from 'three/webgpu';
-export declare function isWebGPU(target: NodeBuilder | Renderer | Backend): boolean;
+export declare function isWebGPU(target: NodeBuilder | Renderer | Renderer['backend']): boolean;