@takram/three-geospatial 0.5.1 → 0.6.0

package/src/webgpu/OutputTextureNode.ts

@@ -1,9 +1,6 @@
 import type { Texture } from 'three'
-import { nodeObject } from 'three/tsl'
 import { TextureNode, type Node, type NodeBuilder } from 'three/webgpu'
 
-import type { NodeObject } from './node'
-
 export class OutputTextureNode extends TextureNode {
   static override get type(): string {
     return 'OutputTextureNode'
@@ -30,4 +27,4 @@ export class OutputTextureNode extends TextureNode {
 
 export const outputTexture = (
   ...args: ConstructorParameters<typeof OutputTextureNode>
-): NodeObject<OutputTextureNode> => nodeObject(new OutputTextureNode(...args))
+): OutputTextureNode => new OutputTextureNode(...args)

package/src/webgpu/RTTextureNode.ts

@@ -1,4 +1,4 @@
-import { nodeObject, uv } from 'three/tsl'
+import { uv } from 'three/tsl'
 import {
   HalfFloatType,
   LinearFilter,
@@ -15,8 +15,6 @@ import {
   type NodeFrame
 } from 'three/webgpu'
 
-import type { NodeObject } from './node'
-
 const { resetRendererState, restoreRendererState } = RendererUtils
 
 function createRenderTarget(): RenderTarget {
@@ -50,7 +48,7 @@ export class RTTextureNode extends TextureNode {
 
   constructor(node: Node, uvNode?: Node) {
     const renderTarget = createRenderTarget()
-    super(renderTarget.texture, uvNode != null ? nodeObject(uvNode) : uv())
+    super(renderTarget.texture, uvNode ?? uv())
     this.node = node
     this.renderTarget = renderTarget
     this.updateBeforeType = NodeUpdateType.FRAME
@@ -84,7 +82,7 @@ export class RTTextureNode extends TextureNode {
     const { material } = this
     // I don't fully understand why, but updates on "node" doesn't propagate
     // unless giving the builder context.
-    material.fragmentNode = nodeObject(this.node).context(builder.getContext())
+    material.fragmentNode = this.node.context(builder.getContext())
     material.needsUpdate = true
     return super.setup(builder)
   }
@@ -107,7 +105,7 @@ export class RTTextureNode extends TextureNode {
 
 export const rtTexture = (
   ...args: ConstructorParameters<typeof RTTextureNode>
-): NodeObject<RTTextureNode> => nodeObject(new RTTextureNode(...args))
+): RTTextureNode => new RTTextureNode(...args)
 
 export const convertToTexture = (
   node: Node & {
@@ -116,7 +114,7 @@ export const convertToTexture = (
     getTextureNode?: () => TextureNode
   },
   name?: string
-): NodeObject<TextureNode> => {
+): TextureNode => {
   let textureNode: TextureNode
   if (node.isTextureNode === true || node.isSampleNode === true) {
     textureNode = node as TextureNode
@@ -128,5 +126,5 @@ export const convertToTexture = (
       textureNode.value.name = name
     }
   }
-  return nodeObject(textureNode)
+  return textureNode
 }

package/src/webgpu/TemporalAntialiasNode.ts

@@ -17,7 +17,6 @@ import {
   ivec2,
   max,
   mix,
-  nodeObject,
   screenCoordinate,
   screenSize,
   screenUV,
@@ -26,6 +25,7 @@ import {
   step,
   struct,
   texture,
+  textureSize,
   uniform,
   vec3,
   vec4
@@ -46,10 +46,9 @@ import { cameraFar, cameraNear } from './accessors'
 import { FnLayout } from './FnLayout'
 import { FnVar } from './FnVar'
 import { haltonOffsets } from './internals'
-import type { Node, NodeObject } from './node'
+import type { Node } from './node'
 import { outputTexture } from './OutputTextureNode'
 import { convertToTexture } from './RTTextureNode'
-import { textureBicubic } from './sampling'
 import { logarithmicToPerspectiveDepth } from './transformations'
 import { isWebGPU } from './utils'
 
@@ -127,11 +126,11 @@ const varianceOffsets = [
 const varianceClipping = /*#__PURE__*/ FnVar(
   (
     inputNode: TextureNode,
-    coord: NodeObject<'ivec2'>,
-    current: NodeObject<'vec4'>,
-    history: NodeObject<'vec4'>,
-    gamma: NodeObject<'float'>
-  ): NodeObject<'vec4'> => {
+    coord: Node<'ivec2'>,
+    current: Node<'vec4'>,
+    history: Node<'vec4'>,
+    gamma: Node<'float'>
+  ): Node<'vec4'> => {
     const moment1 = current.toVar()
     const moment2 = current.pow2().toVar()
 
@@ -169,7 +168,7 @@ const closestDepthStruct = /*#__PURE__*/ struct({
 })
 
 const getClosestDepth = /*#__PURE__*/ FnVar(
-  (depthNode: TextureNode, inputCoord: NodeObject<'ivec2'>) => {
+  (depthNode: TextureNode, inputCoord: Node<'ivec2'>) => {
     const depth = float(1)
     const coord = ivec2(0)
     for (const offset of neighborOffsets) {
@@ -321,9 +320,9 @@ export class TemporalAntialiasNode extends TempNode {
     // Bind and clear the history render target to make sure it's initialized
     // after the resize which triggers a dispose().
     renderer.setRenderTarget(this.resolveRT)
-    void renderer.clear()
+    renderer.clear()
     renderer.setRenderTarget(this.historyRT)
-    void renderer.clear()
+    renderer.clear()
 
     // Copy the current input to the history with scaling.
     renderer.setRenderTarget(this.historyRT)
@@ -419,10 +418,10 @@ export class TemporalAntialiasNode extends TempNode {
   }
 
   private setupResolveNode({ renderer }: NodeBuilder): Node {
-    const getPreviousDepth = (uv: NodeObject<'vec2'>): NodeObject<'float'> => {
+    const getPreviousDepth = (uv: Node<'vec2'>): Node<'float'> => {
       const { previousDepthNode: depthNode } = this
       const depth = depthNode
-        .load(ivec2(uv.mul(depthNode.size(0)).sub(0.5)))
+        .load(ivec2(uv.mul(textureSize(depthNode)).sub(0.5)))
         .toVar()
       return renderer.logarithmicDepthBuffer
         ? logarithmicToPerspectiveDepth(
@@ -482,7 +481,7 @@ export class TemporalAntialiasNode extends TempNode {
 
       const outputColor = vec4(0).toVar()
       If(uvWeight.mul(depthWeight).mul(confidence).greaterThan(0), () => {
-        const historyColor = textureBicubic(this.historyNode, prevUV)
+        const historyColor = texture(this.historyNode, prevUV)
         const clippedColor = varianceClipping(
           this.inputNode,
           coord,
@@ -559,13 +558,11 @@ export const temporalAntialias =
     depthNode: TextureNode,
     velocityNode: TextureNode,
     camera: Camera
-  ): NodeObject<TemporalAntialiasNode> =>
-    nodeObject(
-      new TemporalAntialiasNode(
-        velocityNodeImmutable,
-        convertToTexture(inputNode, 'TemporalAntialiasNode.Input'),
-        depthNode,
-        velocityNode,
-        camera
-      )
+  ): TemporalAntialiasNode =>
+    new TemporalAntialiasNode(
+      velocityNodeImmutable,
+      convertToTexture(inputNode, 'TemporalAntialiasNode.Input'),
+      depthNode,
+      velocityNode,
+      camera
     )

package/src/webgpu/accessors.ts

@@ -2,7 +2,7 @@ import { Vector3, type Camera } from 'three'
 import { reference, uniform } from 'three/tsl'
 import type { UniformNode } from 'three/webgpu'
 
-import type { NodeObject } from './node'
+import type { Node } from './node'
 
 let caches: WeakMap<{}, Record<string, {}>> | undefined
 
@@ -23,31 +23,29 @@ function getCache<T extends {}, U extends {}>(
   return (cache[name] ??= callback()) as U
 }
 
-export const projectionMatrix = (camera: Camera): NodeObject<'mat4'> =>
+export const projectionMatrix = (camera: Camera): Node<'mat4'> =>
   getCache(camera, 'projectionMatrix', () =>
     reference('projectionMatrix', 'mat4', camera).setName('projectionMatrix')
   )
 
-export const viewMatrix = (camera: Camera): NodeObject<'mat4'> =>
+export const viewMatrix = (camera: Camera): Node<'mat4'> =>
   getCache(camera, 'viewMatrix', () =>
     reference('matrixWorldInverse', 'mat4', camera).setName('viewMatrix')
   )
 
-export const inverseProjectionMatrix = (camera: Camera): NodeObject<'mat4'> =>
+export const inverseProjectionMatrix = (camera: Camera): Node<'mat4'> =>
   getCache(camera, 'inverseProjectionMatrix', () =>
     reference('projectionMatrixInverse', 'mat4', camera).setName(
       'inverseProjectionMatrix'
     )
   )
 
-export const inverseViewMatrix = (camera: Camera): NodeObject<'mat4'> =>
+export const inverseViewMatrix = (camera: Camera): Node<'mat4'> =>
   getCache(camera, 'inverseViewMatrix', () =>
     reference('matrixWorld', 'mat4', camera).setName('inverseViewMatrix')
   )
 
-export const cameraPositionWorld = (
-  camera: Camera
-): NodeObject<UniformNode<Vector3>> =>
+export const cameraPositionWorld = (camera: Camera): UniformNode<Vector3> =>
   getCache(camera, 'cameraPositionWorld', () =>
     uniform(new Vector3())
       .setName('cameraPositionWorld')
@@ -56,12 +54,12 @@ export const cameraPositionWorld = (
       })
   )
 
-export const cameraNear = (camera: Camera): NodeObject<'float'> =>
+export const cameraNear = (camera: Camera): Node<'float'> =>
   getCache(camera, 'cameraNear', () =>
     reference('near', 'float', camera).setName('cameraNear')
   )
 
-export const cameraFar = (camera: Camera): NodeObject<'float'> =>
+export const cameraFar = (camera: Camera): Node<'float'> =>
   getCache(camera, 'cameraFar', () =>
     reference('far', 'float', camera).setName('cameraFar')
   )

package/src/webgpu/generators.ts

@@ -10,27 +10,25 @@ import {
   vec3
 } from 'three/tsl'
 
-import type { NodeObject } from './node'
+import type { Node } from './node'
 
 // Reference: https://advances.realtimerendering.com/s2014/index.html
-export const interleavedGradientNoise = (
-  seed: NodeObject<'vec2'>
-): NodeObject<'float'> => {
+export const interleavedGradientNoise = (seed: Node<'vec2'>): Node<'float'> => {
   return seed.dot(vec2(0.06711056, 0.00583715)).fract().mul(52.9829189).fract()
 }
 
 // Reference (sixth from the bottom): https://www.shadertoy.com/view/MslGR8
-export const dithering: NodeObject<'vec3'> = /*#__PURE__*/ Fn(() => {
+export const dithering: Node<'vec3'> = /*#__PURE__*/ Fn(() => {
   const seed = vec2(screenCoordinate.xy).add(time.fract().mul(1337))
   const noise = interleavedGradientNoise(seed)
   return vec3(noise, noise.oneMinus(), noise).sub(0.5).div(255)
 }).once()()
 
 export const equirectGrid = (
-  direction: NodeObject<'vec3'>,
-  lineWidth: NodeObject<'float'>,
-  count: NodeObject<'vec2'> = vec2(90, 45)
-): NodeObject<'float'> => {
+  direction: Node<'vec3'>,
+  lineWidth: Node<'float'>,
+  count: Node<'vec2'> = vec2(90, 45)
+): Node<'float'> => {
   const uv = equirectUV(direction)
   const deltaUV = fwidth(uv)
   const width = lineWidth.mul(deltaUV).mul(0.5)

package/src/webgpu/math.ts

@@ -1,16 +1,16 @@
 import { dot, If, sqrt, struct, vec2, vec4 } from 'three/tsl'
 
 import { FnVar } from './FnVar'
-import type { NodeObject } from './node'
+import type { Node } from './node'
 
 // Reference: https://iquilezles.org/articles/intersectors/
 
 export const raySphereIntersection = /*#__PURE__*/ FnVar(
   (
-    rayOrigin: NodeObject<'vec3'>,
-    rayDirection: NodeObject<'vec3'>,
-    center: NodeObject<'vec3'>,
-    radius: NodeObject<'float'>
+    rayOrigin: Node<'vec3'>,
+    rayDirection: Node<'vec3'>,
+    center: Node<'vec3'>,
+    radius: Node<'float'>
   ) => {
     const a = rayOrigin.sub(center)
     const b = dot(rayDirection, a)
@@ -34,10 +34,10 @@ export const raySpheresIntersectionsStruct = /*#__PURE__*/ struct(
 // Derive ray-sphere intersections with multiple radii at once:
 export const raySpheresIntersections = /*#__PURE__*/ FnVar(
   (
-    rayOrigin: NodeObject<'vec3'>,
-    rayDirection: NodeObject<'vec3'>,
-    center: NodeObject<'vec3'>,
-    radii: NodeObject // Scalar or vector
+    rayOrigin: Node<'vec3'>,
+    rayDirection: Node<'vec3'>,
+    center: Node<'vec3'>,
+    radii: Node // Scalar or vector
   ) => {
     const a = rayOrigin.sub(center)
     const b = dot(rayDirection, a)
@@ -57,10 +57,10 @@ export const raySpheresIntersections = /*#__PURE__*/ FnVar(
 
 export const rayEllipsoidIntersection = /*#__PURE__*/ FnVar(
   (
-    rayOrigin: NodeObject<'vec3'>,
-    rayDirection: NodeObject<'vec3'>,
-    radii: NodeObject<'vec3'>
-  ): NodeObject<'vec2'> => {
+    rayOrigin: Node<'vec3'>,
+    rayDirection: Node<'vec3'>,
+    radii: Node<'vec3'>
+  ): Node<'vec2'> => {
     const ro = rayOrigin.div(radii)
     const rd = rayDirection.div(radii)
     const a = rd.dot(rd)

package/src/webgpu/node.ts

@@ -27,10 +27,9 @@ import {
   uvec4,
   vec2,
   vec3,
-  vec4,
-  type ShaderNodeObject
+  vec4
 } from 'three/tsl'
-import type { Node as N } from 'three/webgpu'
+import { Node as N } from 'three/webgpu'
 
 // prettier-ignore
 const nodes = {
@@ -91,9 +90,7 @@ export type Node<
   T extends NodeType = NodeType
 > = N
 
-export type NodeObject<T extends NodeType | N = N> = ShaderNodeObject<
-  T extends NodeType ? Node<T> : T
->
+export const Node = N
 
 export function node<T extends NodeType>(type: T): (typeof nodes)[T] {
   return nodes[type]

package/src/webgpu/sampling.ts

@@ -1,61 +1,13 @@
-import { add, nodeObject, sub, textureSize, vec2, vec4 } from 'three/tsl'
+import { add, sub, textureSize, vec2 } from 'three/tsl'
 import type { TextureNode } from 'three/webgpu'
 
 import { FnVar } from './FnVar'
-import type { NodeObject } from './node'
-
-// 5-taps version of bicubic sampling.
-// Reference: https://www.shadertoy.com/view/MtVGWz
-export const textureBicubic = /*#__PURE__*/ FnVar(
-  (
-    textureNode: TextureNode,
-    uv: NodeObject<'vec2'>,
-    sharpness: number | NodeObject<'float'> = 0.4
-  ): NodeObject<'vec4'> => {
-    const size = vec2(textureSize(textureNode))
-    const texelSize = size.reciprocal()
-    const position = size.mul(uv)
-    const centerPosition = position.sub(0.5).floor().add(0.5)
-
-    const f = position.sub(centerPosition)
-    const f2 = f.mul(f)
-    const f3 = f.mul(f2)
-
-    // w0 =      -c  * f3 +  2*c      * f2 - c*f
-    // w1 =  (2 - c) * f3 - (3 - c)   * f2       + 1
-    // w2 = -(2 - c) * f3 + (3 - 2*c) * f2 + c*f
-    // w3 =       c  * f3 -  c        * f2
-    const c = nodeObject(sharpness)
-    const cf = c.mul(f)
-    const w0 = c.negate().mul(f3).add(c.mul(2).mul(f2).sub(cf))
-    const w1 = sub(2, c).mul(f3).sub(sub(3, c).mul(f2)).add(1)
-    const w2 = sub(2, c)
-      .negate()
-      .mul(f3)
-      .add(sub(3, c.mul(2)).mul(f2))
-      .add(cf)
-    const w3 = c.mul(f3).sub(c.mul(f2))
-
-    const w12 = w1.add(w2)
-    const tc12 = texelSize.mul(centerPosition.add(w2.div(w12)))
-    const centerColor = textureNode.sample(tc12).rgb
-    const tc0 = texelSize.mul(centerPosition.sub(1))
-    const tc3 = texelSize.mul(centerPosition.add(2))
-
-    return add(
-      vec4(textureNode.sample(vec2(tc12.x, tc0.y)).rgb, 1).mul(w12.x.mul(w0.y)),
-      vec4(textureNode.sample(vec2(tc0.x, tc12.y)).rgb, 1).mul(w0.x.mul(w12.y)),
-      vec4(centerColor, 1).mul(w12.x.mul(w12.y)),
-      vec4(textureNode.sample(vec2(tc3.x, tc12.y)).rgb, 1).mul(w3.x.mul(w12.y)),
-      vec4(textureNode.sample(vec2(tc12.x, tc3.y)).rgb, 1).mul(w12.x.mul(w3.y))
-    )
-  }
-)
+import type { Node } from './node'
 
 // 9-taps version of Catmull-Rom sampling.
 // Reference: https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
 export const textureCatmullRom = /*#__PURE__*/ FnVar(
-  (textureNode: TextureNode, uv: NodeObject<'vec2'>): NodeObject<'vec4'> => {
+  (textureNode: TextureNode, uv: Node<'vec2'>): Node<'vec4'> => {
     const size = vec2(textureSize(textureNode))
     const texelSize = size.reciprocal()
     const position = uv.mul(size)

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/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;