@takram/three-geospatial 0.5.1 → 0.7.0

package/src/webgpu/LensGlareNode.ts

@@ -16,7 +16,6 @@ import {
   instancedArray,
   instanceIndex,
   mat3,
-  nodeObject,
   positionGeometry,
   Return,
   storage,
@@ -40,7 +39,7 @@ import {
 import invariant from 'tiny-invariant'
 
 import { FilterNode } from './FilterNode'
-import type { Node, NodeObject } from './node'
+import type { Node } from './node'
 import { convertToTexture } from './RTTextureNode'
 
 const { resetRendererState, restoreRendererState } = RendererUtils
@@ -187,7 +186,7 @@ export class LensGlareNode extends FilterNode {
     this.rendererState = resetRendererState(renderer, this.rendererState)
 
     renderer.setRenderTarget(renderTarget)
-    void renderer.render(this.mesh, this.camera)
+    renderer.render(this.mesh, this.camera)
 
     restoreRendererState(renderer, this.rendererState)
   }
@@ -258,7 +257,7 @@ export class LensGlareNode extends FilterNode {
 
     this.material.colorNode = this.wireframe
       ? vec4(1)
-      : nodeObject(spikeNode).mul(instance.get('color').mul(intensity))
+      : spikeNode.mul(instance.get('color').mul(intensity))
 
     this.material.vertexNode = Fn(() => {
       const sin = instance.get('sin')
@@ -308,11 +307,9 @@ export class LensGlareNode extends FilterNode {
   }
 }
 
-export const lensGlare = (inputNode: Node | null): NodeObject<LensGlareNode> =>
-  nodeObject(
-    new LensGlareNode(
-      inputNode != null
-        ? convertToTexture(inputNode, 'LensGlareNode.Input')
-        : null
-    )
+export const lensGlare = (inputNode: Node | null): LensGlareNode =>
+  new LensGlareNode(
+    inputNode != null
+      ? convertToTexture(inputNode, 'LensGlareNode.Input')
+      : null
   )

package/src/webgpu/MipmapBlurNode.ts

@@ -1,4 +1,4 @@
-import { add, nodeObject, uv, vec2, vec4 } from 'three/tsl'
+import { add, uv, vec2, vec4 } from 'three/tsl'
 import type {
   NodeBuilder,
   TextureNode,
@@ -8,12 +8,12 @@ import type {
 import invariant from 'tiny-invariant'
 
 import { DualMipmapFilterNode } from './DualMipmapFilterNode'
-import type { Node, NodeObject } from './node'
+import type { Node } from './node'
 
 export const mipmapBlurDownsample = (
   inputNode: TextureNode,
-  texelSize: NodeObject<'vec2'> | NodeObject<UniformNode<Vector2>>
-): NodeObject<'vec4'> => {
+  texelSize: Node<'vec2'> | UniformNode<Vector2>
+): Node<'vec4'> => {
   const center = uv()
   const offset1 = vec4(1, 1, -1, -1).mul(texelSize.xyxy).add(center.xyxy)
   const offset2 = vec4(2, 2, -2, -2).mul(texelSize.xyxy).add(center.xyxy)
@@ -55,8 +55,8 @@ export const mipmapBlurDownsample = (
 
 export const mipmapBlurUpsample = (
   inputNode: TextureNode,
-  texelSize: NodeObject<'vec2'> | NodeObject<UniformNode<Vector2>>
-): NodeObject<'vec4'> => {
+  texelSize: Node<'vec2'> | UniformNode<Vector2>
+): Node<'vec4'> => {
   const center = uv()
   const offset = vec4(1, 1, -1, -1).mul(texelSize.xyxy).add(center.xyxy)
   const uv1 = vec2(center.x, offset.y).toVertexStage() // 0, 1
@@ -110,4 +110,4 @@ export class MipmapBlurNode extends DualMipmapFilterNode {
 
 export const mipmapBlur = (
   ...args: ConstructorParameters<typeof MipmapBlurNode>
-): NodeObject<MipmapBlurNode> => nodeObject(new MipmapBlurNode(...args))
+): MipmapBlurNode => new MipmapBlurNode(...args)

package/src/webgpu/MipmapSurfaceBlurNode.ts

@@ -1,11 +1,11 @@
-import { add, Fn, mix, nodeObject, uniform, uv, vec2, vec4 } from 'three/tsl'
+import { add, Fn, mix, uniform, uv, vec2, vec4 } from 'three/tsl'
 import type { NodeBuilder, TextureNode } from 'three/webgpu'
 import invariant from 'tiny-invariant'
 
 import { DualMipmapFilterNode } from './DualMipmapFilterNode'
-import type { Node, NodeObject } from './node'
+import type { Node } from './node'
 
-const clampToBorder = (uv: NodeObject<'vec2'>): NodeObject<'float'> => {
+const clampToBorder = (uv: Node<'vec2'>): Node<'float'> => {
   return uv.greaterThanEqual(0).all().and(uv.lessThanEqual(1).all()).toFloat()
 }
 
@@ -53,7 +53,7 @@ export class MipmapSurfaceBlurNode extends DualMipmapFilterNode {
 
       const output = inputNode.sample(center).mul(outerWeight)
 
-      let weight: NodeObject
+      let weight: Node
       weight = vec4(
         clampToBorder(uv01),
         clampToBorder(uv02),
@@ -136,5 +136,4 @@ export class MipmapSurfaceBlurNode extends DualMipmapFilterNode {
 
 export const mipmapSurfaceBlur = (
   ...args: ConstructorParameters<typeof MipmapSurfaceBlurNode>
-): NodeObject<MipmapSurfaceBlurNode> =>
-  nodeObject(new MipmapSurfaceBlurNode(...args))
+): MipmapSurfaceBlurNode => new MipmapSurfaceBlurNode(...args)

package/src/webgpu/OutputTexture3DNode.ts

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

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)