@takram/three-geospatial 0.0.1-alpha.8 → 0.1.0

package/src/index.ts

@@ -7,6 +7,7 @@ export * from './decorators'
 export * from './defineShorthand'
 export * from './Ellipsoid'
 export * from './EllipsoidGeometry'
+export * from './EXR3DLoader'
 export * from './Geodetic'
 export * from './math'
 export * from './PointOfView'

package/src/typedArray.ts

@@ -1,3 +1,7 @@
+import {
+  Float16Array,
+  type Float16ArrayConstructor
+} from '@petamoriken/float16'
 import invariant from 'tiny-invariant'
 
 export type TypedArray =
@@ -8,6 +12,7 @@ export type TypedArray =
   | Uint16Array
   | Int32Array
   | Uint32Array
+  | Float16Array
   | Float32Array
   | Float64Array
 
@@ -19,9 +24,11 @@ export type TypedArrayConstructor =
   | Uint16ArrayConstructor
   | Int32ArrayConstructor
   | Uint32ArrayConstructor
+  | Float16ArrayConstructor
   | Float32ArrayConstructor
   | Float64ArrayConstructor
 
+/** @deprecated */
 export type TypedArrayElementType =
   | 'int8'
   | 'uint8'
@@ -29,9 +36,11 @@ export type TypedArrayElementType =
   | 'uint16'
   | 'int32'
   | 'uint32'
+  | 'float16'
   | 'float32'
   | 'float64'
 
+/** @deprecated Use getTypedArrayTextureDataType instead */
 export function getTypedArrayElementType(
   array: TypedArray
 ): TypedArrayElementType {
@@ -44,6 +53,7 @@ export function getTypedArrayElementType(
     array instanceof Uint16Array ? 'uint16' :
     array instanceof Int32Array ? 'int32' :
     array instanceof Uint32Array ? 'uint32' :
+    array instanceof Float16Array ? 'float16' :
     array instanceof Float32Array ? 'float32' :
     array instanceof Float64Array ? 'float64' :
     null
@@ -51,3 +61,20 @@ export function getTypedArrayElementType(
   invariant(type != null)
   return type
 }
+
+export function isTypedArray(value: unknown): value is TypedArray {
+  return (
+    value instanceof Int8Array ||
+    value instanceof Uint8Array ||
+    value instanceof Uint8ClampedArray ||
+    value instanceof Int16Array ||
+    value instanceof Uint16Array ||
+    value instanceof Int32Array ||
+    value instanceof Uint32Array ||
+    value instanceof Float16Array ||
+    value instanceof Float32Array ||
+    value instanceof Float64Array
+  )
+}
+
+export { Float16Array }

package/src/typedArrayParsers.ts

@@ -1,3 +1,5 @@
+import { Float16Array, getFloat16 } from '@petamoriken/float16'
+
 import { type TypedArray, type TypedArrayConstructor } from './typedArray'
 
 let hostLittleEndian: boolean | undefined
@@ -12,11 +14,13 @@ function isHostLittleEndian(): boolean {
   return hostLittleEndian
 }
 
-type GetValue = keyof {
-  [K in keyof DataView as DataView[K] extends (byteOffset: number) => number
-    ? K
-    : never]: DataView[K]
-}
+type GetValue =
+  | keyof {
+      [K in keyof DataView as DataView[K] extends (byteOffset: number) => number
+        ? K
+        : never]: DataView[K]
+    }
+  | 'getFloat16'
 
 function parseTypedArray<T extends TypedArrayConstructor, K extends GetValue>(
   buffer: ArrayBuffer,
@@ -32,9 +36,15 @@ function parseTypedArray<K extends GetValue>(
   littleEndian = true
 ): TypedArray {
   if (littleEndian === isHostLittleEndian()) {
+    // eslint-disable-next-line
+    // @ts-ignore False positive type error in Node.js
     return new TypedArray(buffer)
   }
-  const data = new DataView(buffer)
+  const data = Object.assign(new DataView(buffer), {
+    getFloat16(this: DataView, byteOffset: number, littleEndian?: boolean) {
+      return getFloat16(this, byteOffset, littleEndian)
+    }
+  })
   const array = new TypedArray(data.byteLength / TypedArray.BYTES_PER_ELEMENT)
   for (
     let index = 0, byteIndex = 0;
@@ -77,6 +87,11 @@ export const parseUint32Array: TypedArrayParser<Uint32Array> = (
   littleEndian
 ) => parseTypedArray(buffer, Uint32Array, 'getUint32', littleEndian)
 
+export const parseFloat16Array: TypedArrayParser<Float16Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Float16Array, 'getFloat16', littleEndian)
+
 export const parseFloat32Array: TypedArrayParser<Float32Array> = (
   buffer,
   littleEndian

package/types/DataLoader.d.ts

@@ -1,8 +1,9 @@
 import { Callable } from './types';
 import { TypedArrayParser } from './typedArrayParsers';
 import { TypedArrayLoader } from './TypedArrayLoader';
+import { TypedArray } from './typedArray';
 import { Class, WritableKeysOf } from 'type-fest';
-import { Data3DTexture, DataTexture, Loader, TypedArray } from 'three';
+import { Data3DTexture, DataTexture, Loader } from 'three';
 
 type ParameterProperties<T> = {
     [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K];
@@ -26,12 +27,4 @@ export declare function createData3DTextureLoaderClass<T extends TypedArray>(par
 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>;
-/** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Int16Data2DLoader: Class<DataLoader<DataTexture, Int16Array<ArrayBufferLike>>>;
-/** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Uint16Data2DLoader: Class<DataLoader<DataTexture, Uint16Array<ArrayBufferLike>>>;
-/** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Float32Data2DLoader: Class<DataLoader<DataTexture, Float32Array<ArrayBufferLike>>>;
-/** @deprecated Use createData3DTextureLoaderClass instead. */
-export declare const Float32Data3DLoader: Class<DataLoader<Data3DTexture, Float32Array<ArrayBufferLike>>>;
 export {};

package/types/EXR3DLoader.d.ts

@@ -0,0 +1,7 @@
+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/TypedArrayLoader.d.ts

@@ -1,6 +1,7 @@
 import { TypedArrayParser } from './typedArrayParsers';
+import { TypedArray } from './typedArray';
 import { Class } from 'type-fest';
-import { Loader, TypedArray } from 'three';
+import { Loader } from 'three';
 
 export declare abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
     abstract parseTypedArray(buffer: ArrayBuffer): T;

package/types/index.d.ts

@@ -7,6 +7,7 @@ export * from './decorators';
 export * from './defineShorthand';
 export * from './Ellipsoid';
 export * from './EllipsoidGeometry';
+export * from './EXR3DLoader';
 export * from './Geodetic';
 export * from './math';
 export * from './PointOfView';

package/types/typedArray.d.ts

@@ -1,4 +1,10 @@
-export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
-export type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
-export type TypedArrayElementType = 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32' | 'float32' | 'float64';
+import { Float16Array, Float16ArrayConstructor } from '@petamoriken/float16';
+
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float16Array | Float32Array | Float64Array;
+export type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float16ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+/** @deprecated */
+export type TypedArrayElementType = 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32' | 'float16' | 'float32' | 'float64';
+/** @deprecated Use getTypedArrayTextureDataType instead */
 export declare function getTypedArrayElementType(array: TypedArray): TypedArrayElementType;
+export declare function isTypedArray(value: unknown): value is TypedArray;
+export { Float16Array };

package/types/typedArrayParsers.d.ts

@@ -1,4 +1,5 @@
 import { TypedArray } from './typedArray';
+import { Float16Array } from '@petamoriken/float16';
 
 export type TypedArrayParser<T extends TypedArray> = (buffer: ArrayBuffer, littleEndian?: boolean) => T;
 export declare const parseUint8Array: TypedArrayParser<Uint8Array>;
@@ -7,5 +8,6 @@ export declare const parseUint16Array: TypedArrayParser<Uint16Array>;
 export declare const parseInt16Array: TypedArrayParser<Int16Array>;
 export declare const parseInt32Array: TypedArrayParser<Int32Array>;
 export declare const parseUint32Array: TypedArrayParser<Uint32Array>;
+export declare const parseFloat16Array: TypedArrayParser<Float16Array>;
 export declare const parseFloat32Array: TypedArrayParser<Float32Array>;
 export declare const parseFloat64Array: TypedArrayParser<Float64Array>;