@takram/three-geospatial 0.7.1 → 0.9.0

package/src/webgpu/accessors.ts

@@ -1,8 +1,21 @@
-import { Vector3, type Camera } from 'three'
-import { reference, uniform } from 'three/tsl'
+import type { Camera, Vector3 } from 'three'
+import {
+  cameraFar as cameraFarTSL,
+  cameraNear as cameraNearTSL,
+  cameraPosition,
+  cameraProjectionMatrix,
+  cameraProjectionMatrixInverse,
+  cameraViewMatrix,
+  cameraWorldMatrix,
+  depth,
+  Fn,
+  reference,
+  uniform
+} from 'three/tsl'
 import type { UniformNode } from 'three/webgpu'
 
 import type { Node } from './node'
+import { depthToViewZ } from './transformations'
 
 let caches: WeakMap<{}, Record<string, {}>> | undefined
 
@@ -23,43 +36,69 @@ function getCache<T extends {}, U extends {}>(
   return (cache[name] ??= callback()) as U
 }
 
-export const projectionMatrix = (camera: Camera): Node<'mat4'> =>
-  getCache(camera, 'projectionMatrix', () =>
-    reference('projectionMatrix', 'mat4', camera).setName('projectionMatrix')
-  )
+export const projectionMatrix = (camera?: Camera | null): Node<'mat4'> =>
+  camera != null
+    ? getCache(camera, 'projectionMatrix', () =>
+        reference('projectionMatrix', 'mat4', camera).setName(
+          'projectionMatrix'
+        )
+      )
+    : cameraProjectionMatrix
 
-export const viewMatrix = (camera: Camera): Node<'mat4'> =>
-  getCache(camera, 'viewMatrix', () =>
-    reference('matrixWorldInverse', 'mat4', camera).setName('viewMatrix')
-  )
+export const viewMatrix = (camera?: Camera | null): Node<'mat4'> =>
+  camera != null
+    ? getCache(camera, 'viewMatrix', () =>
+        reference('matrixWorldInverse', 'mat4', camera).setName('viewMatrix')
+      )
+    : cameraViewMatrix
 
-export const inverseProjectionMatrix = (camera: Camera): Node<'mat4'> =>
-  getCache(camera, 'inverseProjectionMatrix', () =>
-    reference('projectionMatrixInverse', 'mat4', camera).setName(
-      'inverseProjectionMatrix'
-    )
-  )
+export const inverseProjectionMatrix = (
+  camera?: Camera | null
+): Node<'mat4'> =>
+  camera != null
+    ? getCache(camera, 'inverseProjectionMatrix', () =>
+        reference('projectionMatrixInverse', 'mat4', camera).setName(
+          'inverseProjectionMatrix'
+        )
+      )
+    : cameraProjectionMatrixInverse
 
-export const inverseViewMatrix = (camera: Camera): Node<'mat4'> =>
-  getCache(camera, 'inverseViewMatrix', () =>
-    reference('matrixWorld', 'mat4', camera).setName('inverseViewMatrix')
-  )
+export const inverseViewMatrix = (camera?: Camera | null): Node<'mat4'> =>
+  camera != null
+    ? getCache(camera, 'inverseViewMatrix', () =>
+        reference('matrixWorld', 'mat4', camera).setName('inverseViewMatrix')
+      )
+    : cameraWorldMatrix // TODO: Not always
 
-export const cameraPositionWorld = (camera: Camera): UniformNode<Vector3> =>
-  getCache(camera, 'cameraPositionWorld', () =>
-    uniform(new Vector3())
-      .setName('cameraPositionWorld')
-      .onRenderUpdate((_, { value }) => {
-        value.setFromMatrixPosition(camera.matrixWorld)
-      })
-  )
+export const cameraPositionWorld = (
+  camera?: Camera | null
+): UniformNode<Vector3> =>
+  camera != null
+    ? getCache(camera, 'cameraPositionWorld', () =>
+        uniform('vec3')
+          .setName('cameraPositionWorld')
+          .onRenderUpdate((_, { value }) => {
+            value.setFromMatrixPosition(camera.matrixWorld)
+          })
+      )
+    : cameraPosition
 
-export const cameraNear = (camera: Camera): Node<'float'> =>
-  getCache(camera, 'cameraNear', () =>
-    reference('near', 'float', camera).setName('cameraNear')
-  )
+export const cameraNear = (camera?: Camera | null): Node<'float'> =>
+  camera != null
+    ? getCache(camera, 'cameraNear', () =>
+        reference('near', 'float', camera).setName('cameraNear')
+      )
+    : cameraNearTSL
 
-export const cameraFar = (camera: Camera): Node<'float'> =>
-  getCache(camera, 'cameraFar', () =>
-    reference('far', 'float', camera).setName('cameraFar')
-  )
+export const cameraFar = (camera?: Camera | null): Node<'float'> =>
+  camera != null
+    ? getCache(camera, 'cameraFar', () =>
+        reference('far', 'float', camera).setName('cameraFar')
+      )
+    : cameraFarTSL
+
+export const viewZ = Fn(
+  ({ camera }): Node<'float'> => depthToViewZ(depth, camera)
+)
+  .once()()
+  .toVar('viewZ')

package/src/webgpu/debug.ts

@@ -6,65 +6,56 @@ import { QuadGeometry } from '../QuadGeometry'
 
 async function debugShader(
   renderer: Renderer,
-  mesh: Mesh
-): Promise<
-  Awaited<{
-    fragmentShader: string | null
-    vertexShader: string | null
-  }>
-> {
-  return await renderer.debug
-    .getShaderAsync(new Scene(), new Camera(), mesh)
-    .then(result => {
-      return result
-    })
-    .catch((error: unknown) => {
-      console.error(error)
-      return { fragmentShader: null, vertexShader: null }
-    })
+  material: NodeMaterial
+): Promise<{
+  vertexShader: string | null
+  fragmentShader: string | null
+}> {
+  const mesh = new Mesh(new QuadGeometry(), material)
+  try {
+    return await renderer.debug.getShaderAsync(new Scene(), new Camera(), mesh)
+  } catch (error: unknown) {
+    console.error(error)
+    return { vertexShader: null, fragmentShader: null }
+  } finally {
+    mesh.geometry.dispose()
+  }
 }
 
-export function debugFragmentNode(
+export async function debugMaterial(
   renderer: Renderer,
   material: NodeMaterial
-): void {
-  const mesh = new Mesh(new QuadGeometry(), material)
-  void debugShader(renderer, mesh)
-    .then(result => {
-      console.log(result.fragmentShader)
-    })
-    .finally(() => {
-      mesh.geometry.dispose()
-    })
+): Promise<string | null> {
+  const { vertexShader, fragmentShader } = await debugShader(renderer, material)
+  return vertexShader != null && fragmentShader != null
+    ? `// Vertex shader\n\n${vertexShader}\n// Fragment shader\n\n${fragmentShader}`
+    : null
 }
 
-export function debugVertexNode(
+export async function debugVertexNode(
   renderer: Renderer,
   material: NodeMaterial
-): void {
-  const mesh = new Mesh(new QuadGeometry(), material)
-  void debugShader(renderer, mesh)
-    .then(result => {
-      console.log(result.vertexShader)
-    })
-    .finally(() => {
-      mesh.geometry.dispose()
-    })
+): Promise<string | null> {
+  return (await debugShader(renderer, material)).vertexShader
+}
+
+export async function debugFragmentNode(
+  renderer: Renderer,
+  material: NodeMaterial
+): Promise<string | null> {
+  return (await debugShader(renderer, material)).fragmentShader
 }
 
-export function debugNode(renderer: Renderer, node: Node): void {
+export async function debugNode(
+  renderer: Renderer,
+  node: Node
+): Promise<string | null> {
   const material = new NodeMaterial()
   material.vertexNode = vec4(positionGeometry.xy, 0, 1)
-  material.fragmentNode = node
-  const mesh = new Mesh(new QuadGeometry(), material)
-  void debugShader(renderer, mesh)
-    .then(result => {
-      console.log(result.fragmentShader)
-    })
-    .finally(() => {
-      material.dispose()
-      mesh.geometry.dispose()
-    })
+  material.fragmentNode = node.toConst('debugNode')
+  const shader = await debugShader(renderer, material)
+  material.dispose()
+  return shader.fragmentShader
 }
 
 export function hookFunction<

package/src/webgpu/events.ts

@@ -0,0 +1,18 @@
+import { OnBeforeObjectUpdate, OnObjectUpdate } from 'three/tsl'
+import { NodeUpdateType, type Node, type NodeFrame } from 'three/webgpu'
+
+// TODO: File a PR for these:
+
+export const OnFrameUpdate = (callback: (frame: NodeFrame) => void): Node => {
+  const node = OnObjectUpdate(callback)
+  node.updateType = NodeUpdateType.NONE
+  return node
+}
+
+export const OnBeforeFrameUpdate = (
+  callback: (frame: NodeFrame) => void
+): Node => {
+  const node = OnBeforeObjectUpdate(callback)
+  node.updateBeforeType = NodeUpdateType.FRAME
+  return node
+}

package/src/webgpu/index.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/src/webgpu/math.ts

@@ -1,8 +1,110 @@
-import { dot, If, sqrt, struct, vec2, vec4 } from 'three/tsl'
+import {
+  bool,
+  bvec2,
+  bvec3,
+  bvec4,
+  dot,
+  If,
+  overloadingFn,
+  sqrt,
+  struct,
+  uvec2,
+  uvec3,
+  uvec4,
+  vec2
+} from 'three/tsl'
 
+import { FnLayout } from './FnLayout'
 import { FnVar } from './FnVar'
 import type { Node } from './node'
 
+const bvec2Not = /*#__PURE__*/ FnLayout({
+  name: 'bvec2Not',
+  type: 'bvec2',
+  inputs: [{ name: 'x', type: 'bvec2' }]
+})(([x]) => x.notEqual(bool(true)))
+
+const bvec3Not = /*#__PURE__*/ FnLayout({
+  name: 'bvec3Not',
+  type: 'bvec3',
+  inputs: [{ name: 'x', type: 'bvec3' }]
+})(([x]) => x.notEqual(bool(true)))
+
+const bvec4Not = /*#__PURE__*/ FnLayout({
+  name: 'bvec4Not',
+  type: 'bvec4',
+  inputs: [{ name: 'x', type: 'bvec4' }]
+})(([x]) => x.notEqual(bool(true)))
+
+// WORKAROUND: PR on this https://github.com/mrdoob/three.js/pull/33442
+export const bvecNot = /*#__PURE__*/ overloadingFn([
+  bvec2Not,
+  bvec3Not,
+  bvec4Not
+])
+
+const bvec2And = /*#__PURE__*/ FnLayout({
+  name: 'bvec2And',
+  type: 'bvec2',
+  inputs: [
+    { name: 'x', type: 'bvec2' },
+    { name: 'y', type: 'bvec2' }
+  ]
+})(([x, y]) => bvec2(uvec2(x).mul(uvec2(y))))
+
+const bvec3And = /*#__PURE__*/ FnLayout({
+  name: 'bvec3And',
+  type: 'bvec3',
+  inputs: [
+    { name: 'x', type: 'bvec3' },
+    { name: 'y', type: 'bvec3' }
+  ]
+})(([x, y]) => bvec3(uvec3(x).mul(uvec3(y))))
+
+const bvec4And = /*#__PURE__*/ FnLayout({
+  name: 'bvec4And',
+  type: 'bvec4',
+  inputs: [
+    { name: 'x', type: 'bvec4' },
+    { name: 'y', type: 'bvec4' }
+  ]
+})(([x, y]) => bvec4(uvec4(x).mul(uvec4(y))))
+
+export const bvecAnd = /*#__PURE__*/ overloadingFn([
+  bvec2And,
+  bvec3And,
+  bvec4And
+])
+
+const bvec2Or = /*#__PURE__*/ FnLayout({
+  name: 'bvec2Or',
+  type: 'bvec2',
+  inputs: [
+    { name: 'x', type: 'bvec2' },
+    { name: 'y', type: 'bvec2' }
+  ]
+})(([x, y]) => uvec2(x).add(uvec2(y)).notEqual(0))
+
+const bvec3Or = /*#__PURE__*/ FnLayout({
+  name: 'bvec3Or',
+  type: 'bvec3',
+  inputs: [
+    { name: 'x', type: 'bvec3' },
+    { name: 'y', type: 'bvec3' }
+  ]
+})(([x, y]) => uvec3(x).add(uvec3(y)).notEqual(0))
+
+const bvec4Or = /*#__PURE__*/ FnLayout({
+  name: 'bvec4Or',
+  type: 'bvec4',
+  inputs: [
+    { name: 'x', type: 'bvec4' },
+    { name: 'y', type: 'bvec4' }
+  ]
+})(([x, y]) => uvec4(x).add(uvec4(y)).notEqual(0))
+
+export const bvecOr = /*#__PURE__*/ overloadingFn([bvec2Or, bvec3Or, bvec4Or])
+
 // Reference: https://iquilezles.org/articles/intersectors/
 
 export const raySphereIntersection = /*#__PURE__*/ FnVar(
@@ -15,7 +117,7 @@ export const raySphereIntersection = /*#__PURE__*/ FnVar(
     const a = rayOrigin.sub(center)
     const b = dot(rayDirection, a)
     const c = dot(a, a).sub(radius.pow2())
-    const discriminant = b.pow2().sub(c).toVar()
+    const discriminant = b.pow2().sub(c).toConst()
 
     const intersection = vec2(-1)
     If(discriminant.greaterThanEqual(0), () => {
@@ -26,10 +128,10 @@ export const raySphereIntersection = /*#__PURE__*/ FnVar(
   }
 )
 
-export const raySpheresIntersectionsStruct = /*#__PURE__*/ struct(
-  { near: 'vec4', far: 'vec4' },
-  'raySpheresIntersections'
-)
+export const raySpheresIntersectionsStruct = /*#__PURE__*/ struct({
+  near: 'vec4',
+  far: 'vec4'
+})
 
 // Derive ray-sphere intersections with multiple radii at once:
 export const raySpheresIntersections = /*#__PURE__*/ FnVar(
@@ -42,15 +144,14 @@ export const raySpheresIntersections = /*#__PURE__*/ FnVar(
     const a = rayOrigin.sub(center)
     const b = dot(rayDirection, a)
     const c = dot(a, a).sub(radii.pow2())
-    const discriminant = b.pow2().sub(c).toVar()
+    const discriminant = b.pow2().sub(c).toConst()
 
-    const near = vec4(-1)
-    const far = vec4(-1)
-    If(discriminant.greaterThanEqual(0), () => {
-      const Q = sqrt(discriminant)
-      near.assign(b.negate().sub(Q))
-      far.assign(b.negate().add(Q))
-    })
+    // Reference: https://github.com/GameTechDev/OutdoorLightScattering/blob/master/fx/Common.fxh#L148
+    const mask = vec2(discriminant.greaterThanEqual(0)).toConst()
+    const inverseMask = mask.oneMinus().toConst()
+    const Q = sqrt(discriminant.max(0)).toConst()
+    const near = mask.mul(b.negate().sub(Q)).sub(inverseMask)
+    const far = mask.mul(b.negate().add(Q)).sub(inverseMask)
     return raySpheresIntersectionsStruct(near, far)
   }
 )
@@ -69,7 +170,7 @@ export const rayEllipsoidIntersection = /*#__PURE__*/ FnVar(
     const discriminant = b
       .pow2()
       .sub(a.mul(c.sub(1)))
-      .toVar()
+      .toConst()
 
     const intersections = vec2(-1)
     If(discriminant.greaterThanEqual(0), () => {

package/src/webgpu/sampling.ts

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

package/src/webgpu/transformations.ts

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

package/types/PointOfView.d.ts

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

package/types/STBNLoader.d.ts

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