@takram/three-geospatial 0.2.2 → 0.3.0

package/src/{EXR3DLoader.ts → EXRTextureLoader.ts}

@@ -1,20 +1,28 @@
-import { Data3DTexture, Loader } from 'three'
+import { DataTexture, Loader, type LoadingManager } from 'three'
 import { EXRLoader } from 'three-stdlib'
 
-export class EXR3DLoader extends Loader<Data3DTexture> {
-  depth?: number
+export interface EXRTextureLoaderOptions {
+  width?: number
+  height?: number
+}
+
+export class EXRTextureLoader extends Loader<DataTexture> {
+  options: EXRTextureLoaderOptions
 
-  setDepth(value: number): this {
-    this.depth = value
-    return this
+  constructor(options: EXRTextureLoaderOptions = {}, manager?: LoadingManager) {
+    super(manager)
+    this.options = options
   }
 
   override load(
     url: string,
-    onLoad: (data: Data3DTexture) => void,
+    onLoad?: (data: DataTexture) => void,
     onProgress?: (event: ProgressEvent) => void,
     onError?: (error: unknown) => void
-  ): void {
+  ): DataTexture {
+    const { width, height } = this.options
+    const texture = new DataTexture(null, width, height)
+
     const loader = new EXRLoader(this.manager)
     loader.setRequestHeader(this.requestHeader)
     loader.setPath(this.path)
@@ -22,16 +30,19 @@ export class EXR3DLoader extends Loader<Data3DTexture> {
     loader.load(
       url,
       exr => {
-        const { data, width, height } = exr.image
-        const depth = this.depth ?? Math.sqrt(height)
-        const texture = new Data3DTexture(data, width, height / depth, depth)
+        const { image } = exr
+        texture.image = {
+          data: image.data,
+          width: width ?? image.width,
+          height: height ?? image.height
+        }
         texture.type = exr.type
         texture.format = exr.format
         texture.colorSpace = exr.colorSpace
         texture.needsUpdate = true
 
         try {
-          onLoad(texture)
+          onLoad?.(texture)
         } catch (error) {
           if (onError != null) {
             onError(error)
@@ -44,5 +55,7 @@ export class EXR3DLoader extends Loader<Data3DTexture> {
       onProgress,
       onError
     )
+
+    return texture
   }
 }

package/src/STBNLoader.ts

@@ -1,21 +1,36 @@
-import { NearestFilter, RedFormat, RepeatWrapping } from 'three'
+import {
+  Data3DTexture,
+  NearestFilter,
+  RedFormat,
+  RepeatWrapping,
+  type LoadingManager
+} from 'three'
 
 import {
   STBN_TEXTURE_DEPTH,
   STBN_TEXTURE_HEIGHT,
   STBN_TEXTURE_WIDTH
 } from './constants'
-import { createData3DTextureLoaderClass } from './DataLoader'
+import { DataTextureLoader } from './DataTextureLoader'
 import { parseUint8Array } from './typedArrayParsers'
 
-export const STBNLoader = createData3DTextureLoaderClass(parseUint8Array, {
-  format: RedFormat,
-  minFilter: NearestFilter,
-  magFilter: NearestFilter,
-  wrapS: RepeatWrapping,
-  wrapT: RepeatWrapping,
-  wrapR: RepeatWrapping,
-  width: STBN_TEXTURE_WIDTH,
-  height: STBN_TEXTURE_HEIGHT,
-  depth: STBN_TEXTURE_DEPTH
-})
+export class STBNLoader extends DataTextureLoader<Data3DTexture> {
+  constructor(manager?: LoadingManager) {
+    super(
+      Data3DTexture,
+      parseUint8Array,
+      {
+        format: RedFormat,
+        minFilter: NearestFilter,
+        magFilter: NearestFilter,
+        wrapS: RepeatWrapping,
+        wrapT: RepeatWrapping,
+        wrapR: RepeatWrapping,
+        width: STBN_TEXTURE_WIDTH,
+        height: STBN_TEXTURE_HEIGHT,
+        depth: STBN_TEXTURE_DEPTH
+      },
+      manager
+    )
+  }
+}

package/src/TilingScheme.ts

@@ -1,6 +1,6 @@
 import { Vector2 } from 'three'
 
-import { type GeodeticLike } from './Geodetic'
+import type { GeodeticLike } from './Geodetic'
 import { Rectangle, type RectangleLike } from './Rectangle'
 import { TileCoordinate, type TileCoordinateLike } from './TileCoordinate'
 

package/src/TypedArrayLoader.ts

@@ -1,12 +1,16 @@
-import { Loader } from 'three'
-import { type Class } from 'type-fest'
+import { Loader, type LoadingManager } from 'three'
 
 import { ArrayBufferLoader } from './ArrayBufferLoader'
-import { type TypedArray } from './typedArray'
-import { type TypedArrayParser } from './typedArrayParsers'
+import type { TypedArray } from './typedArray'
+import type { TypedArrayParser } from './typedArrayParsers'
 
-export abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
-  abstract parseTypedArray(buffer: ArrayBuffer): T
+export class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
+  parser: TypedArrayParser<T>
+
+  constructor(parser: TypedArrayParser<T>, manager?: LoadingManager) {
+    super(manager)
+    this.parser = parser
+  }
 
   override load(
     url: string,
@@ -22,7 +26,7 @@ export abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
       url,
       arrayBuffer => {
         try {
-          onLoad(this.parseTypedArray(arrayBuffer))
+          onLoad(this.parser(arrayBuffer))
         } catch (error) {
           if (onError != null) {
             onError(error)
@@ -37,17 +41,3 @@ export abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
     )
   }
 }
-
-export function createTypedArrayLoaderClass<T extends TypedArray>(
-  parser: TypedArrayParser<T>
-): Class<TypedArrayLoader<T>> {
-  return class extends TypedArrayLoader<T> {
-    readonly parseTypedArray = parser
-  }
-}
-
-export function createTypedArrayLoader<T extends TypedArray>(
-  parser: TypedArrayParser<T>
-): TypedArrayLoader<T> {
-  return new (createTypedArrayLoaderClass(parser))()
-}

package/src/capabilities.ts

@@ -0,0 +1,5 @@
+import type { WebGLRenderer } from 'three'
+
+export function isFloatLinearSupported(renderer: WebGLRenderer): boolean {
+  return renderer.getContext().getExtension('OES_texture_float_linear') != null
+}

package/src/constants.ts

@@ -2,5 +2,6 @@ export const STBN_TEXTURE_WIDTH = 128
 export const STBN_TEXTURE_HEIGHT = 128
 export const STBN_TEXTURE_DEPTH = 64
 
+// Reference to the latest assets.
 const ref = '9627216cc50057994c98a2118f3c4a23765d43b9'
 export const DEFAULT_STBN_URL = `https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/${ref}/packages/core/assets/stbn.bin`

package/src/decorators.ts

@@ -23,7 +23,6 @@ export function define(name: string) {
               this.defines ??= {}
               this.defines[name] = '1'
             } else {
-              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
               delete this.defines?.[name]
             }
             this.needsUpdate = true

package/src/defineShorthand.ts

@@ -1,4 +1,4 @@
-import { type Uniform } from 'three'
+import type { Uniform } from 'three'
 
 // TODO: Make mutable value types (e.g. vectors, matrices) read-only.
 

package/src/index.ts

@@ -1,13 +1,15 @@
 export * from './ArrayBufferLoader'
 export * from './assertions'
 export * from './bufferGeometry'
+export * from './capabilities'
 export * from './constants'
-export * from './DataLoader'
+export * from './DataTextureLoader'
 export * from './decorators'
 export * from './defineShorthand'
 export * from './Ellipsoid'
 export * from './EllipsoidGeometry'
-export * from './EXR3DLoader'
+export * from './EXR3DTextureLoader'
+export * from './EXRTextureLoader'
 export * from './Geodetic'
 export * from './math'
 export * from './PointOfView'
@@ -19,5 +21,5 @@ export * from './TilingScheme'
 export * from './typedArray'
 export * from './TypedArrayLoader'
 export * from './typedArrayParsers'
-export * from './types'
+export type * from './types'
 export * from './unrollLoops'

package/src/r3f/EastNorthUpFrame.tsx

@@ -1,7 +1,7 @@
-import { type ElementProps } from '@react-three/fiber'
+import type { ElementProps } from '@react-three/fiber'
 import { useEffect, useMemo, type FC, type ReactNode } from 'react'
 import { Group, Matrix4, Vector3 } from 'three'
-import { type SetOptional } from 'type-fest'
+import type { SetOptional } from 'type-fest'
 
 import { Ellipsoid } from '../Ellipsoid'
 import { Geodetic, type GeodeticLike } from '../Geodetic'

package/src/r3f/EllipsoidMesh.tsx

@@ -3,9 +3,8 @@ import {
   type ElementProps,
   type ThreeElement
 } from '@react-three/fiber'
-import { useRef, type FC } from 'react'
-import { mergeRefs } from 'react-merge-refs'
-import { type Mesh } from 'three'
+import type { FC } from 'react'
+import type { Mesh } from 'three'
 
 import { EllipsoidGeometry } from '../EllipsoidGeometry'
 
@@ -26,10 +25,9 @@ export const EllipsoidMesh: FC<EllipsoidMeshProps> = ({
   children,
   ...props
 }) => {
-  const ref = useRef<Mesh | null>(null)
   extend({ EllipsoidGeometry })
   return (
-    <mesh ref={mergeRefs([ref, forwardedRef])} {...props}>
+    <mesh ref={forwardedRef} {...props}>
       <ellipsoidGeometry args={args} />
       {children}
     </mesh>

package/src/r3f/index.ts

@@ -1,3 +1,3 @@
 export * from './EastNorthUpFrame'
 export * from './EllipsoidMesh'
-export * from './types'
+export type * from './types'

package/src/r3f/types.ts

@@ -1,4 +1,4 @@
-import { type MathType, type MathTypes } from '@react-three/fiber'
+import type { MathType, MathTypes } from '@react-three/fiber'
 
 export type OverwriteMathProps<T> = {
   [K in keyof T]: Exclude<T[K], undefined> extends MathTypes

package/src/typedArrayParsers.ts

@@ -1,6 +1,6 @@
 import { Float16Array, getFloat16 } from '@petamoriken/float16'
 
-import { type TypedArray, type TypedArrayConstructor } from './typedArray'
+import type { TypedArray, TypedArrayConstructor } from './typedArray'
 
 let hostLittleEndian: boolean | undefined
 

package/src/types.ts

@@ -1,4 +1,4 @@
-import { type Uniform } from 'three'
+import type { FloatType, HalfFloatType, Uniform } from 'three'
 
 export type Callable = (...args: any) => any
 
@@ -6,3 +6,5 @@ export type UniformMap<T> = Omit<Map<string, Uniform>, 'get'> & {
   get: <K extends keyof T>(key: K) => T[K]
   set: <K extends keyof T>(key: K, value: T[K]) => void
 }
+
+export type AnyFloatType = typeof FloatType | typeof HalfFloatType

package/types/DataTextureLoader.d.ts

@@ -0,0 +1,27 @@
+import { Loader, ColorSpace, Data3DTexture, DataTexture, LoadingManager, MagnificationTextureFilter, Mapping, MinificationTextureFilter, PixelFormat, TextureDataType, Wrapping } from 'three';
+import { Class } from 'type-fest';
+import { TypedArray } from './typedArray';
+import { TypedArrayParser } from './typedArrayParsers';
+export interface DataTextureLoaderOptions {
+    width?: number;
+    height?: number;
+    depth?: number;
+    mapping?: Mapping;
+    wrapS?: Wrapping;
+    wrapT?: Wrapping;
+    wrapR?: Wrapping;
+    magFilter?: MagnificationTextureFilter;
+    minFilter?: MinificationTextureFilter;
+    format?: PixelFormat;
+    type?: TextureDataType;
+    anisotropy?: number;
+    colorSpace?: ColorSpace;
+    manager?: LoadingManager;
+}
+export declare class DataTextureLoader<T extends DataTexture | Data3DTexture = DataTexture | Data3DTexture, U extends TypedArray = TypedArray> extends Loader<T> {
+    textureClass: Class<T>;
+    parser: TypedArrayParser<U>;
+    options: DataTextureLoaderOptions;
+    constructor(textureClass: Class<T>, parser: TypedArrayParser<U>, options?: DataTextureLoaderOptions, manager?: LoadingManager);
+    load(url: string, onLoad?: (data: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): T;
+}

package/types/EXR3DTextureLoader.d.ts

@@ -0,0 +1,11 @@
+import { Data3DTexture, Loader, LoadingManager } from 'three';
+export interface EXR3DTextureLoaderOptions {
+    width?: number;
+    height?: number;
+    depth?: number;
+}
+export declare class EXR3DTextureLoader extends Loader<Data3DTexture> {
+    options: EXR3DTextureLoaderOptions;
+    constructor(options?: EXR3DTextureLoaderOptions, manager?: LoadingManager);
+    load(url: string, onLoad?: (data: Data3DTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): Data3DTexture;
+}

package/types/EXRTextureLoader.d.ts

@@ -0,0 +1,10 @@
+import { DataTexture, Loader, LoadingManager } from 'three';
+export interface EXRTextureLoaderOptions {
+    width?: number;
+    height?: number;
+}
+export declare class EXRTextureLoader extends Loader<DataTexture> {
+    options: EXRTextureLoaderOptions;
+    constructor(options?: EXRTextureLoaderOptions, manager?: LoadingManager);
+    load(url: string, onLoad?: (data: DataTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): DataTexture;
+}

package/types/STBNLoader.d.ts

@@ -1 +1,5 @@
-export declare const STBNLoader: import('type-fest').Class<import('./DataLoader').DataLoader<import('three').Data3DTexture, Uint8Array<ArrayBufferLike>>>;
+import { Data3DTexture, LoadingManager } from 'three';
+import { DataTextureLoader } from './DataTextureLoader';
+export declare class STBNLoader extends DataTextureLoader<Data3DTexture> {
+    constructor(manager?: LoadingManager);
+}

package/types/TypedArrayLoader.d.ts

@@ -1,10 +1,8 @@
-import { Loader } from 'three';
-import { Class } from 'type-fest';
+import { Loader, LoadingManager } from 'three';
 import { TypedArray } from './typedArray';
 import { TypedArrayParser } from './typedArrayParsers';
-export declare abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
-    abstract parseTypedArray(buffer: ArrayBuffer): T;
+export declare class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
+    parser: TypedArrayParser<T>;
+    constructor(parser: TypedArrayParser<T>, manager?: LoadingManager);
     load(url: string, onLoad: (data: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
 }
-export declare function createTypedArrayLoaderClass<T extends TypedArray>(parser: TypedArrayParser<T>): Class<TypedArrayLoader<T>>;
-export declare function createTypedArrayLoader<T extends TypedArray>(parser: TypedArrayParser<T>): TypedArrayLoader<T>;

package/types/capabilities.d.ts

@@ -0,0 +1,2 @@
+import { WebGLRenderer } from 'three';
+export declare function isFloatLinearSupported(renderer: WebGLRenderer): boolean;

package/types/index.d.ts

@@ -1,13 +1,15 @@
 export * from './ArrayBufferLoader';
 export * from './assertions';
 export * from './bufferGeometry';
+export * from './capabilities';
 export * from './constants';
-export * from './DataLoader';
+export * from './DataTextureLoader';
 export * from './decorators';
 export * from './defineShorthand';
 export * from './Ellipsoid';
 export * from './EllipsoidGeometry';
-export * from './EXR3DLoader';
+export * from './EXR3DTextureLoader';
+export * from './EXRTextureLoader';
 export * from './Geodetic';
 export * from './math';
 export * from './PointOfView';
@@ -19,5 +21,5 @@ export * from './TilingScheme';
 export * from './typedArray';
 export * from './TypedArrayLoader';
 export * from './typedArrayParsers';
-export * from './types';
+export type * from './types';
 export * from './unrollLoops';

package/types/r3f/index.d.ts

@@ -1,3 +1,3 @@
 export * from './EastNorthUpFrame';
 export * from './EllipsoidMesh';
-export * from './types';
+export type * from './types';

package/types/types.d.ts

@@ -1,6 +1,7 @@
-import { Uniform } from 'three';
+import { FloatType, HalfFloatType, Uniform } from 'three';
 export type Callable = (...args: any) => any;
 export type UniformMap<T> = Omit<Map<string, Uniform>, 'get'> & {
     get: <K extends keyof T>(key: K) => T[K];
     set: <K extends keyof T>(key: K, value: T[K]) => void;
 };
+export type AnyFloatType = typeof FloatType | typeof HalfFloatType;

package/src/DataLoader.ts

@@ -1,164 +0,0 @@
-import {
-  ByteType,
-  Data3DTexture,
-  DataTexture,
-  FloatType,
-  HalfFloatType,
-  IntType,
-  LinearFilter,
-  Loader,
-  RGBAFormat,
-  ShortType,
-  UnsignedByteType,
-  UnsignedIntType,
-  UnsignedShortType,
-  type TextureDataType
-} from 'three'
-import invariant from 'tiny-invariant'
-import { type Class, type WritableKeysOf } from 'type-fest'
-
-import { Float16Array, type TypedArray } from './typedArray'
-import {
-  createTypedArrayLoaderClass,
-  type TypedArrayLoader
-} from './TypedArrayLoader'
-import { type TypedArrayParser } from './typedArrayParsers'
-import { type Callable } from './types'
-
-// TODO: Move to types
-type ParameterProperties<T> = {
-  [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K]
-}
-
-function getTextureDataType(array: TypedArray): TextureDataType {
-  // prettier-ignore
-  const type = (
-    array instanceof Int8Array ? ByteType :
-    array instanceof Uint8Array ? UnsignedByteType :
-    array instanceof Uint8ClampedArray ? UnsignedByteType :
-    array instanceof Int16Array ? ShortType :
-    array instanceof Uint16Array ? UnsignedShortType :
-    array instanceof Int32Array ? IntType :
-    array instanceof Uint32Array ? UnsignedIntType :
-    array instanceof Float16Array ? HalfFloatType :
-    array instanceof Float32Array ? FloatType :
-    array instanceof Float64Array ? FloatType :
-    null
-  )
-  invariant(type != null)
-  return type
-}
-
-export interface DataTextureParameters
-  extends Omit<Partial<ParameterProperties<DataTexture>>, 'image'> {
-  width?: number
-  height?: number
-}
-
-export interface Data3DTextureParameters
-  extends Omit<Partial<ParameterProperties<Data3DTexture>>, 'image'> {
-  width?: number
-  height?: number
-  depth?: number
-}
-
-const defaultDataTextureParameter = {
-  format: RGBAFormat,
-  minFilter: LinearFilter,
-  magFilter: LinearFilter
-} satisfies DataTextureParameters & Data3DTextureParameters
-
-export abstract class DataLoader<
-  T extends DataTexture | Data3DTexture = DataTexture | Data3DTexture,
-  U extends TypedArray = TypedArray
-> extends Loader<T> {
-  abstract readonly Texture: Class<T>
-  abstract readonly TypedArrayLoader: Class<TypedArrayLoader<U>>
-
-  readonly parameters: DataTextureParameters & Data3DTextureParameters = {}
-
-  override load(
-    url: string,
-    onLoad: (data: T) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (error: unknown) => void
-  ): void {
-    const texture = new this.Texture()
-    const loader = new this.TypedArrayLoader(this.manager)
-    loader.setRequestHeader(this.requestHeader)
-    loader.setPath(this.path)
-    loader.setWithCredentials(this.withCredentials)
-    loader.load(
-      url,
-      array => {
-        texture.image.data =
-          array instanceof Float16Array ? new Uint16Array(array.buffer) : array
-        const { width, height, depth, ...params } = this.parameters
-        if (width != null) {
-          texture.image.width = width
-        }
-        if (height != null) {
-          texture.image.height = height
-        }
-        if ('depth' in texture.image && depth != null) {
-          texture.image.depth = depth
-        }
-
-        // Populate the default texture type for the array type.
-        texture.type = getTextureDataType(array)
-
-        Object.assign(texture, params)
-        texture.needsUpdate = true
-        onLoad(texture)
-      },
-      onProgress,
-      onError
-    )
-  }
-}
-
-function createDataLoaderClass<
-  T extends DataTexture | Data3DTexture,
-  U extends TypedArray
->(
-  Texture: Class<T>,
-  parser: TypedArrayParser<U>,
-  parameters?: DataTextureParameters
-): Class<DataLoader<T, U>> {
-  return class extends DataLoader<T, U> {
-    readonly Texture = Texture
-    readonly TypedArrayLoader = createTypedArrayLoaderClass(parser)
-    readonly parameters = {
-      ...defaultDataTextureParameter,
-      ...parameters
-    }
-  }
-}
-
-export function createData3DTextureLoaderClass<T extends TypedArray>(
-  parser: TypedArrayParser<T>,
-  parameters?: Data3DTextureParameters
-): Class<DataLoader<Data3DTexture, T>> {
-  return createDataLoaderClass(Data3DTexture, parser, parameters)
-}
-
-export function createDataTextureLoaderClass<T extends TypedArray>(
-  parser: TypedArrayParser<T>,
-  parameters?: DataTextureParameters
-): Class<DataLoader<DataTexture, T>> {
-  return createDataLoaderClass(DataTexture, parser, parameters)
-}
-
-export function createData3DTextureLoader<T extends TypedArray>(
-  parser: TypedArrayParser<T>,
-  parameters?: Data3DTextureParameters
-): DataLoader<Data3DTexture, T> {
-  return new (createData3DTextureLoaderClass(parser, parameters))()
-}
-
-export function createDataTextureLoader<T extends TypedArray>(
-  parser: TypedArrayParser<T>,
-  parameters?: DataTextureParameters
-): DataLoader<DataTexture, T> {
-  return new (createDataTextureLoaderClass(parser, parameters))()
-}