@takram/three-geospatial 0.2.1 → 0.3.0

package/src/r3f/EllipsoidMesh.tsx

@@ -3,9 +3,8 @@ import {
   type ElementProps,
   type ThreeElement
 } from '@react-three/fiber'
-import { forwardRef, useRef } 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'
 
@@ -20,15 +19,17 @@ export interface EllipsoidMeshProps
   args?: ConstructorParameters<typeof EllipsoidGeometry>
 }
 
-export const EllipsoidMesh = /*#__PURE__*/ forwardRef<Mesh, EllipsoidMeshProps>(
-  function Ellipsoid({ args, children, ...props }, forwardedRef) {
-    const ref = useRef<Mesh | null>(null)
-    extend({ EllipsoidGeometry })
-    return (
-      <mesh ref={mergeRefs([ref, forwardedRef])} {...props}>
-        <ellipsoidGeometry args={args} />
-        {children}
-      </mesh>
-    )
-  }
-)
+export const EllipsoidMesh: FC<EllipsoidMeshProps> = ({
+  ref: forwardedRef,
+  args,
+  children,
+  ...props
+}) => {
+  extend({ EllipsoidGeometry })
+  return (
+    <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/Ellipsoid.d.ts

@@ -14,4 +14,5 @@ export declare class Ellipsoid {
     getEastNorthUpFrame(position: Vector3, result?: Matrix4): Matrix4;
     getIntersection(ray: Ray, result?: Vector3): Vector3 | undefined;
     getOsculatingSphereCenter(surfacePosition: Vector3, radius: number, result?: Vector3): Vector3;
+    getNormalAtHorizon(position: Vector3, direction: Vector3, result?: Vector3): Vector3;
 }

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/EastNorthUpFrame.d.ts

@@ -1,4 +1,5 @@
-import { ReactNode } from 'react';
+import { ElementProps } from '@react-three/fiber';
+import { FC, ReactNode } from 'react';
 import { Group } from 'three';
 import { SetOptional } from 'type-fest';
 import { Ellipsoid } from '../Ellipsoid';
@@ -6,9 +7,9 @@ import { GeodeticLike } from '../Geodetic';
 declare class EastNorthUpFrameGroup extends Group {
     set(longitude: number, latitude: number, height: number, ellipsoid?: Ellipsoid): void;
 }
-export interface EastNorthUpFrameProps extends SetOptional<GeodeticLike, 'height'> {
+export interface EastNorthUpFrameProps extends ElementProps<typeof EastNorthUpFrameGroup, EastNorthUpFrameGroup>, SetOptional<GeodeticLike, 'height'> {
     ellipsoid?: Ellipsoid;
     children?: ReactNode;
 }
-export declare const EastNorthUpFrame: import('react').ForwardRefExoticComponent<EastNorthUpFrameProps & import('react').RefAttributes<EastNorthUpFrameGroup>>;
+export declare const EastNorthUpFrame: FC<EastNorthUpFrameProps>;
 export {};

package/types/r3f/EllipsoidMesh.d.ts

@@ -1,4 +1,5 @@
 import { ElementProps, ThreeElement } from '@react-three/fiber';
+import { FC } from 'react';
 import { Mesh } from 'three';
 import { EllipsoidGeometry } from '../EllipsoidGeometry';
 declare module '@react-three/fiber' {
@@ -9,4 +10,4 @@ declare module '@react-three/fiber' {
 export interface EllipsoidMeshProps extends Omit<ElementProps<typeof Mesh>, 'args'> {
     args?: ConstructorParameters<typeof EllipsoidGeometry>;
 }
-export declare const EllipsoidMesh: import('react').ForwardRefExoticComponent<Omit<EllipsoidMeshProps, "ref"> & import('react').RefAttributes<Mesh<import('three').BufferGeometry<import('three').NormalBufferAttributes>, import('three').Material | import('three').Material[], import('three').Object3DEventMap>>>;
+export declare const EllipsoidMesh: FC<EllipsoidMeshProps>;

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))()
-}

package/src/Texture3DLoader.ts

@@ -1,81 +0,0 @@
-import {
-  Data3DTexture,
-  ImageLoader,
-  LinearFilter,
-  Loader,
-  RepeatWrapping
-} from 'three'
-
-export class Texture3DLoader extends Loader<Data3DTexture> {
-  override load(
-    url: string,
-    onLoad: (data: Data3DTexture) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (error: unknown) => void
-  ): void {
-    const loader = new ImageLoader(this.manager)
-    loader.setRequestHeader(this.requestHeader)
-    loader.setPath(this.path)
-    loader.setWithCredentials(this.withCredentials)
-    loader.load(
-      url,
-      image => {
-        const canvas = document.createElement('canvas')
-        const context = canvas.getContext('2d')
-        if (context == null) {
-          onError?.(new Error('Could not obtain canvas context.'))
-          return
-        }
-
-        // Assume cubic 3D texture.
-        const { width, height } = image
-        const size = Math.min(width, height)
-        canvas.width = width
-        canvas.height = height
-        context.drawImage(image, 0, 0)
-        const imageData = context.getImageData(0, 0, width, height).data
-        let data: Uint8Array
-
-        if (width < height) {
-          data = new Uint8Array(imageData.buffer)
-        } else {
-          data = new Uint8Array(imageData.length)
-          const sizeSq = size ** 2
-          for (let z = 0; z < size; ++z) {
-            for (let y = 0; y < size; ++y) {
-              for (let x = 0; x < size; ++x) {
-                const src = (x + z * size + y * sizeSq) * 4
-                const dest = (x + y * size + z * sizeSq) * 4
-                data[dest + 0] = imageData[src + 0]
-                data[dest + 1] = imageData[src + 1]
-                data[dest + 2] = imageData[src + 2]
-                data[dest + 3] = imageData[src + 3]
-              }
-            }
-          }
-        }
-
-        const texture = new Data3DTexture(data, size, size, size)
-        texture.minFilter = LinearFilter
-        texture.magFilter = LinearFilter
-        texture.wrapS = RepeatWrapping
-        texture.wrapT = RepeatWrapping
-        texture.wrapR = RepeatWrapping
-        texture.needsUpdate = true
-
-        try {
-          onLoad(texture)
-        } catch (error) {
-          if (onError != null) {
-            onError(error)
-          } else {
-            console.error(error)
-          }
-          this.manager.itemError(url)
-        }
-      },
-      onProgress,
-      onError
-    )
-  }
-}

package/types/DataLoader.d.ts

@@ -1,29 +0,0 @@
-import { Data3DTexture, DataTexture, Loader } from 'three';
-import { Class, WritableKeysOf } from 'type-fest';
-import { TypedArray } from './typedArray';
-import { TypedArrayLoader } from './TypedArrayLoader';
-import { TypedArrayParser } from './typedArrayParsers';
-import { Callable } from './types';
-type ParameterProperties<T> = {
-    [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K];
-};
-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;
-}
-export declare 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;
-    load(url: string, onLoad: (data: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
-}
-export declare function createData3DTextureLoaderClass<T extends TypedArray>(parser: TypedArrayParser<T>, parameters?: Data3DTextureParameters): Class<DataLoader<Data3DTexture, T>>;
-export declare function createDataTextureLoaderClass<T extends TypedArray>(parser: TypedArrayParser<T>, parameters?: DataTextureParameters): Class<DataLoader<DataTexture, T>>;
-export declare function createData3DTextureLoader<T extends TypedArray>(parser: TypedArrayParser<T>, parameters?: Data3DTextureParameters): DataLoader<Data3DTexture, T>;
-export declare function createDataTextureLoader<T extends TypedArray>(parser: TypedArrayParser<T>, parameters?: DataTextureParameters): DataLoader<DataTexture, T>;
-export {};

package/types/EXR3DLoader.d.ts

@@ -1,6 +0,0 @@
-import { Data3DTexture, Loader } from 'three';
-export declare class EXR3DLoader extends Loader<Data3DTexture> {
-    depth?: number;
-    setDepth(value: number): this;
-    load(url: string, onLoad: (data: Data3DTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
-}

package/types/Texture3DLoader.d.ts

@@ -1,4 +0,0 @@
-import { Data3DTexture, Loader } from 'three';
-export declare class Texture3DLoader extends Loader<Data3DTexture> {
-    load(url: string, onLoad: (data: Data3DTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
-}