Merge branch 'migrate-three-types'

Author: shotamatsuda

package.json

@@ -52,7 +52,7 @@
     "@types/react-dom": "19.0.0",
     "@types/shallowequal": "^1.1.5",
     "@types/string-template": "^1.0.7",
-    "@types/three": "0.180.0",
+    "@types/three": "0.181.0",
     "@vitejs/plugin-react": "^4.7.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",

packages/atmosphere/WEBGPU.md

@@ -358,7 +358,7 @@ const aerialPerspective: (
   colorNode: Node,
   depthNode: Node,
   normalNode?: Node | null
-) => NodeObject<AerialPerspectiveNode>
+) => AerialPerspectiveNode
 ```
 
 ### Dependencies
@@ -459,8 +459,8 @@ scene.backgroundNode = skyBackground(context)
 
 <!-- prettier-ignore -->
 ```ts
-const sky: (atmosphereContext: AtmosphereContext) => NodeObject<SkyNode>
-const skyBackground: (atmosphereContext: AtmosphereContext) => NodeObject<SkyNode>
+const sky: (atmosphereContext: AtmosphereContext) => SkyNode
+const skyBackground: (atmosphereContext: AtmosphereContext) => SkyNode
 ```
 
 ### Dependencies
@@ -597,7 +597,7 @@ scene.environmentNode = skyEnvironment(context)
 const skyEnvironment: (
   atmosphereContext: AtmosphereContext,
   size?: number
-) => NodeObject<SkyEnvironmentNode>
+) => SkyEnvironmentNode
 ```
 
 ### Dependencies

packages/atmosphere/src/PrecomputedTexturesLoader.ts

@@ -5,6 +5,7 @@ import {
   HalfFloatType,
   LinearFilter,
   Loader,
+  type DataTextureImageData,
   type LoadingManager,
   type Texture,
   type WebGLRenderer
@@ -18,6 +19,7 @@ import {
   Float16Array,
   isFloatLinearSupported,
   parseFloat16Array,
+  reinterpretType,
   type AnyFloatType
 } from '@takram/three-geospatial'
 
@@ -127,9 +129,12 @@ export class PrecomputedTexturesLoader extends Loader<PrecomputedTextures> {
           // EXR and binary data are parsed to Uint16Array, which must be
           // converted to Float32Array when FloatType is used.
           if (this.type === FloatType) {
-            texture.image.data = new Float32Array(
-              new Float16Array(texture.image.data.buffer)
-            )
+            reinterpretType<DataTextureImageData>(texture.image)
+            if (texture.image.data != null) {
+              texture.image.data = new Float32Array(
+                new Float16Array(texture.image.data?.buffer)
+              )
+            }
           }
           texture.minFilter = LinearFilter
           texture.magFilter = LinearFilter

packages/atmosphere/src/helpers/sampleTexture.ts

@@ -1,9 +1,16 @@
-import { HalfFloatType, Vector3, type Texture, type Vector2 } from 'three'
+import {
+  HalfFloatType,
+  Vector3,
+  type DataTextureImageData,
+  type Texture,
+  type Vector2
+} from 'three'
 
 import {
   clamp,
   Float16Array,
   isTypedArray,
+  reinterpretType,
   type TypedArray
 } from '@takram/three-geospatial'
 
@@ -19,6 +26,7 @@ const float16ArrayCache = /*#__PURE__*/ new WeakMap<
 function getImageData(texture: Texture): TypedArray | undefined {
   // Image data is stored in the userData in case of normal texture.
   // See PrecomputedTexturesGenerator.
+  reinterpretType<DataTextureImageData>(texture.image)
   let data: TypedArray | undefined = isTypedArray(texture.image.data)
     ? texture.image.data
     : isTypedArray(texture.userData.imageData)
@@ -56,6 +64,7 @@ export function sampleTexture(
   if (data == null) {
     return result.setScalar(0)
   }
+  reinterpretType<DataTextureImageData>(texture.image)
   const { width, height } = texture.image
   const x = clamp(uv.x, 0, 1) * (width - 1)
   const y = clamp(uv.y, 0, 1) * (height - 1)

packages/atmosphere/src/webgpu/AerialPerspectiveNode.ts

@@ -3,7 +3,6 @@ import {
   Fn,
   If,
   mix,
-  nodeObject,
   positionGeometry,
   remapClamp,
   select,
@@ -22,8 +21,7 @@ import {
   projectionMatrix,
   rayEllipsoidIntersection,
   screenToPositionView,
-  type Node,
-  type NodeObject
+  type Node
 } from '@takram/three-geospatial/webgpu'
 
 import type { AtmosphereContextNode } from './AtmosphereContextNode'
@@ -91,11 +89,10 @@ export class AerialPerspectiveNode extends TempNode {
       altitudeCorrectionUnit
     } = this.atmosphereContext
 
-    const colorNode = nodeObject(this.colorNode)
-    const depthNode = nodeObject(this.depthNode)
+    const { colorNode, depthNode, normalNode } = this
     const depth = depthNode.r.toVar()
 
-    const getSurfacePositionECEF = (): NodeObject<'vec3'> => {
+    const getSurfacePositionECEF = (): Node<'vec3'> => {
       const viewZ = depthToViewZ(depth, cameraNear(camera), cameraFar(camera), {
         perspective: camera.isPerspectiveCamera,
         logarithmic: builder.renderer.logarithmicDepthBuffer
@@ -113,7 +110,7 @@ export class AerialPerspectiveNode extends TempNode {
       return matrixWorldToECEF.mul(vec4(positionWorld, 1)).xyz
     }
 
-    const getRayDirectionECEF = (): NodeObject<'vec3'> => {
+    const getRayDirectionECEF = (): Node<'vec3'> => {
       const positionView = inverseProjectionMatrix(camera).mul(
         vec4(positionGeometry, 1)
       ).xyz
@@ -161,14 +158,13 @@ export class AerialPerspectiveNode extends TempNode {
       }
 
       const illuminance = Fn(() => {
-        if (this.normalNode == null) {
+        if (normalNode == null) {
           throw new Error(
             'The "normalNode" is required when the "light" is set.'
           )
         }
 
         // Normal vector of the surface:
-        const normalNode = nodeObject(this.normalNode)
         const normalView = normalNode.xyz
         const normalWorld = inverseViewMatrix(camera).mul(
           vec4(normalView, 0)
@@ -239,5 +235,4 @@ export class AerialPerspectiveNode extends TempNode {
 
 export const aerialPerspective = (
   ...args: ConstructorParameters<typeof AerialPerspectiveNode>
-): NodeObject<AerialPerspectiveNode> =>
-  nodeObject(new AerialPerspectiveNode(...args))
+): AerialPerspectiveNode => new AerialPerspectiveNode(...args)

packages/atmosphere/src/webgpu/AtmosphereContextBaseNode.ts

@@ -1,7 +1,7 @@
 import { float, vec3 } from 'three/tsl'
-import { Node, type NodeBuilder } from 'three/webgpu'
+import type { NodeBuilder } from 'three/webgpu'
 
-import type { NodeObject } from '@takram/three-geospatial/webgpu'
+import { Node } from '@takram/three-geospatial/webgpu'
 
 import {
   AtmosphereParameters,
@@ -19,11 +19,11 @@ import type {
 } from './dimensional'
 
 export interface DensityProfileLayerNodes {
-  width: NodeObject<Length>
-  expTerm: NodeObject<Dimensionless>
-  expScale: NodeObject<InverseLength>
-  linearTerm: NodeObject<InverseLength>
-  constantTerm: NodeObject<Dimensionless>
+  width: Node<Length>
+  expTerm: Node<Dimensionless>
+  expScale: Node<InverseLength>
+  linearTerm: Node<InverseLength>
+  constantTerm: Node<Dimensionless>
 }
 
 function densityProfileLayerNodes(
@@ -65,24 +65,24 @@ export class AtmosphereContextBaseNode extends Node {
 
   readonly parameters: AtmosphereParameters
 
-  worldToUnit: NodeObject<Dimensionless>
-  solarIrradiance: NodeObject<IrradianceSpectrum>
-  sunAngularRadius: NodeObject<Angle>
-  bottomRadius: NodeObject<Length>
-  topRadius: NodeObject<Length>
+  worldToUnit: Node<Dimensionless>
+  solarIrradiance: Node<IrradianceSpectrum>
+  sunAngularRadius: Node<Angle>
+  bottomRadius: Node<Length>
+  topRadius: Node<Length>
   rayleighDensity: DensityProfileNodes
-  rayleighScattering: NodeObject<ScatteringSpectrum>
+  rayleighScattering: Node<ScatteringSpectrum>
   mieDensity: DensityProfileNodes
-  mieScattering: NodeObject<ScatteringSpectrum>
-  mieExtinction: NodeObject<ScatteringSpectrum>
-  miePhaseFunctionG: NodeObject<Dimensionless>
+  mieScattering: Node<ScatteringSpectrum>
+  mieExtinction: Node<ScatteringSpectrum>
+  miePhaseFunctionG: Node<Dimensionless>
   absorptionDensity: DensityProfileNodes
-  absorptionExtinction: NodeObject<ScatteringSpectrum>
-  groundAlbedo: NodeObject<DimensionlessSpectrum>
-  minCosSun: NodeObject<Dimensionless>
-  sunRadianceToLuminance: NodeObject<DimensionlessSpectrum>
-  skyRadianceToLuminance: NodeObject<DimensionlessSpectrum>
-  luminanceScale: NodeObject<Dimensionless>
+  absorptionExtinction: Node<ScatteringSpectrum>
+  groundAlbedo: Node<DimensionlessSpectrum>
+  minCosSun: Node<Dimensionless>
+  sunRadianceToLuminance: Node<DimensionlessSpectrum>
+  skyRadianceToLuminance: Node<DimensionlessSpectrum>
+  luminanceScale: Node<Dimensionless>
 
   constructor(parameters = new AtmosphereParameters()) {
     super(null)

packages/atmosphere/src/webgpu/AtmosphereLUTNode.ts

@@ -112,7 +112,7 @@ export class AtmosphereLUTNode extends Node {
     return this.textureNodes[name]
   }
 
-  private *compute(
+  private *performCompute(
     renderer: Renderer,
     context: AtmosphereLUTTexturesContext
   ): Iterable<boolean> {
@@ -165,7 +165,7 @@ export class AtmosphereLUTNode extends Node {
     const context = this.textures.createContext()
     this.updating = true
     try {
-      await timeSlice(this.compute(renderer, context))
+      await timeSlice(this.performCompute(renderer, context))
     } finally {
       this.updating = false
       context.dispose()

packages/atmosphere/src/webgpu/AtmosphereLUTTexturesWebGL.ts

@@ -113,11 +113,11 @@ function clearRenderTarget(
     if (renderTarget instanceof RenderTarget3D) {
       for (let i = 0; i < renderTarget.depth; ++i) {
         renderer.setRenderTarget(renderTarget, i)
-        void renderer.clearColor()
+        renderer.clearColor()
       }
     } else {
       renderer.setRenderTarget(renderTarget)
-      void renderer.clearColor()
+      renderer.clearColor()
     }
   }
 }

packages/atmosphere/src/webgpu/AtmosphereLUTTexturesWebGPU.ts

@@ -2,6 +2,8 @@ import {
   Box3,
   LinearFilter,
   NoColorSpace,
+  type Data3DTextureImageData,
+  type DataTextureImageData,
   type Texture,
   type Vector2,
   type Vector3
@@ -31,8 +33,7 @@ import {
 } from 'three/webgpu'
 import invariant from 'tiny-invariant'
 
-import type { AnyFloatType } from '@takram/three-geospatial'
-import type { NodeObject } from '@takram/three-geospatial/webgpu'
+import { reinterpretType, type AnyFloatType } from '@takram/three-geospatial'
 
 import type {
   AtmosphereLUTTexture3DName,
@@ -79,6 +80,7 @@ export function setupStorageTexture(
   size: Vector2
 ): void {
   texture.type = textureType
+  reinterpretType<DataTextureImageData>(texture.image)
   texture.image.width = size.x
   texture.image.height = size.y
 }
@@ -89,6 +91,7 @@ export function setupStorage3DTexture(
   size: Vector3
 ): void {
   texture.type = textureType
+  reinterpretType<Data3DTextureImageData>(texture.image)
   texture.image.width = size.x
   texture.image.height = size.y
   texture.image.depth = size.z
@@ -188,12 +191,12 @@ export class AtmosphereLUTTexturesWebGPU extends AtmosphereLUTTextures {
     'higherOrderScattering'
   )
 
-  private transmittanceNode?: NodeObject<ComputeNode>
-  private directIrradianceNode?: NodeObject<ComputeNode>
-  private singleScatteringNode?: NodeObject<ComputeNode>
-  private scatteringDensityNode?: NodeObject<ComputeNode>
-  private indirectIrradianceNode?: NodeObject<ComputeNode>
-  private multipleScatteringNode?: NodeObject<ComputeNode>
+  private transmittanceNode?: ComputeNode
+  private directIrradianceNode?: ComputeNode
+  private singleScatteringNode?: ComputeNode
+  private scatteringDensityNode?: ComputeNode
+  private indirectIrradianceNode?: ComputeNode
+  private multipleScatteringNode?: ComputeNode
 
   private readonly scatteringOrder = uniform(0)
 

packages/atmosphere/src/webgpu/AtmosphereLightNode.ts

@@ -9,18 +9,10 @@ import {
 } from 'three/tsl'
 import { AnalyticLightNode, type NodeBuilder } from 'three/webgpu'
 
-import type { Node, NodeObject } from '@takram/three-geospatial/webgpu'
-
 import type { AtmosphereLight } from './AtmosphereLight'
 import { getTransmittanceToSun } from './common'
 import { getSkyIlluminance } from './runtime'
 
-type CorrectLightingContext = {
-  [K in keyof LightingContext]: LightingContext[K] extends Node
-    ? NodeObject<LightingContext[K]>
-    : LightingContext[K]
-}
-
 export class AtmosphereLightNode extends AnalyticLightNode<AtmosphereLight> {
   static override get type(): string {
     return 'AtmosphereLightNode'
@@ -67,7 +59,7 @@ export class AtmosphereLightNode extends AnalyticLightNode<AtmosphereLight> {
     })()
 
     // Yes, it's an indirect but should be fine to update it here.
-    const lightingContext = builder.getContext() as CorrectLightingContext
+    const lightingContext = builder.getContext() as unknown as LightingContext
     lightingContext.irradiance.addAssign(skyIlluminance)
 
     // Derive the view-space sun direction.