@takram/three-geospatial 0.0.1-alpha.4 → 0.0.1-alpha.5

package/src/typedArrayParsers.ts

@@ -0,0 +1,77 @@
+import { type TypedArray, type TypedArrayConstructor } from './typedArray'
+
+type GetValue = keyof {
+  [K in keyof DataView as DataView[K] extends (byteOffset: number) => number
+    ? K
+    : never]: DataView[K]
+}
+
+function parseTypedArray<T extends TypedArrayConstructor, K extends GetValue>(
+  buffer: ArrayBuffer,
+  TypedArray: T,
+  getValue: K,
+  littleEndian?: boolean
+): InstanceType<T>
+
+function parseTypedArray<K extends GetValue>(
+  buffer: ArrayBuffer,
+  TypedArray: TypedArrayConstructor,
+  getValue: K,
+  littleEndian = true
+): TypedArray {
+  const data = new DataView(buffer)
+  const array = new TypedArray(data.byteLength / TypedArray.BYTES_PER_ELEMENT)
+  for (
+    let index = 0, byteIndex = 0;
+    index < array.length;
+    ++index, byteIndex += TypedArray.BYTES_PER_ELEMENT
+  ) {
+    array[index] = data[getValue](byteIndex, littleEndian)
+  }
+  return array
+}
+
+export type TypedArrayParser<T extends TypedArray> = (
+  buffer: ArrayBuffer,
+  littleEndian?: boolean
+) => T
+
+export const parseUint8Array: TypedArrayParser<Uint8Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Uint8Array, 'getUint8', littleEndian)
+
+export const parseInt8Array: TypedArrayParser<Int8Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Int8Array, 'getInt8', littleEndian)
+
+export const parseUint16Array: TypedArrayParser<Uint16Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Uint16Array, 'getUint16', littleEndian)
+
+export const parseInt16Array: TypedArrayParser<Int16Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Int16Array, 'getInt16', littleEndian)
+
+export const parseInt32Array: TypedArrayParser<Int32Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Int32Array, 'getInt32', littleEndian)
+
+export const parseUint32Array: TypedArrayParser<Uint32Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Uint32Array, 'getUint32', littleEndian)
+
+export const parseFloat32Array: TypedArrayParser<Float32Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Float32Array, 'getFloat32', littleEndian)
+
+export const parseFloat64Array: TypedArrayParser<Float64Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Float64Array, 'getFloat64', littleEndian)

package/types/DataLoader.d.ts

@@ -1,67 +1,37 @@
 import { Callable } from './types';
-import { Float32ArrayLoader, Int16ArrayLoader, Uint16ArrayLoader, TypedArrayLoader } from './TypedArrayLoader';
-import { Class } from 'type-fest';
-import { Data3DTexture, DataTexture, Loader, Texture, TypedArray } from 'three';
+import { TypedArrayParser } from './typedArrayParsers';
+import { TypedArrayLoader } from './TypedArrayLoader';
+import { Class, WritableKeysOf } from 'type-fest';
+import { Data3DTexture, DataTexture, Loader, TypedArray } from 'three';
 
-export interface ImageSize {
-    width: number;
-    height: number;
+type ParameterProperties<T> = {
+    [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K];
+};
+export type DataTextureParameters = Omit<Partial<ParameterProperties<DataTexture>>, 'image'> & {
+    width?: number;
+    height?: number;
+};
+export type Data3DTextureParameters = Omit<Partial<ParameterProperties<Data3DTexture>>, 'image'> & {
+    width?: number;
+    height?: number;
     depth?: number;
-}
-export type DataTextureParameters = Omit<Partial<{
-    [K in keyof Texture as Texture[K] extends Callable ? never : K]: Texture[K];
-}>, 'image'>;
-export declare abstract class DataLoader<T extends DataTexture | Data3DTexture, U extends TypedArray> extends Loader<T> {
+};
+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;
+    readonly parameters: DataTextureParameters & Data3DTextureParameters;
     load(url: string, onLoad: (data: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
 }
-export declare class Int16Data2DLoader extends DataLoader<DataTexture, Int16Array> {
-    readonly Texture: typeof DataTexture;
-    readonly TypedArrayLoader: typeof Int16ArrayLoader;
-    readonly parameters: {
-        type: 1015;
-        format: 1023;
-        wrapS: 1001;
-        wrapT: 1001;
-        minFilter: 1006;
-        magFilter: 1006;
-    };
-}
-export declare class Uint16Data2DLoader extends DataLoader<DataTexture, Uint16Array> {
-    readonly Texture: typeof DataTexture;
-    readonly TypedArrayLoader: typeof Uint16ArrayLoader;
-    readonly parameters: {
-        type: 1015;
-        format: 1023;
-        wrapS: 1001;
-        wrapT: 1001;
-        minFilter: 1006;
-        magFilter: 1006;
-    };
-}
-export declare class Float32Data2DLoader extends DataLoader<DataTexture, Float32Array> {
-    readonly Texture: typeof DataTexture;
-    readonly TypedArrayLoader: typeof Float32ArrayLoader;
-    readonly parameters: {
-        type: 1015;
-        format: 1023;
-        wrapS: 1001;
-        wrapT: 1001;
-        minFilter: 1006;
-        magFilter: 1006;
-    };
-}
-export declare class Float32Data3DLoader extends DataLoader<Data3DTexture, Float32Array> {
-    readonly Texture: typeof Data3DTexture;
-    readonly TypedArrayLoader: typeof Float32ArrayLoader;
-    readonly parameters: {
-        type: 1015;
-        format: 1023;
-        wrapS: 1001;
-        wrapT: 1001;
-        minFilter: 1006;
-        magFilter: 1006;
-    };
-}
+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>;
+/** @deprecated Use createDataTextureLoaderClass instead. */
+export declare const Int16Data2DLoader: Class<DataLoader<DataTexture, Int16Array>>;
+/** @deprecated Use createDataTextureLoaderClass instead. */
+export declare const Uint16Data2DLoader: Class<DataLoader<DataTexture, Uint16Array>>;
+/** @deprecated Use createDataTextureLoaderClass instead. */
+export declare const Float32Data2DLoader: Class<DataLoader<DataTexture, Float32Array>>;
+/** @deprecated Use createData3DTextureLoaderClass instead. */
+export declare const Float32Data3DLoader: Class<DataLoader<Data3DTexture, Float32Array>>;
+export {};

package/types/TypedArrayLoader.d.ts

@@ -1,16 +1,16 @@
-import { parseFloat32Array, parseInt16Array, parseUint16Array } from './typedArray';
+import { TypedArrayParser } from './typedArrayParsers';
+import { Class } from 'type-fest';
 import { Loader, TypedArray } from 'three';
 
 export declare abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
     abstract parseTypedArray(buffer: ArrayBuffer): T;
     load(url: string, onLoad: (data: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
 }
-export declare class Int16ArrayLoader extends TypedArrayLoader<Int16Array> {
-    readonly parseTypedArray: typeof parseInt16Array;
-}
-export declare class Uint16ArrayLoader extends TypedArrayLoader<Uint16Array> {
-    readonly parseTypedArray: typeof parseUint16Array;
-}
-export declare class Float32ArrayLoader extends TypedArrayLoader<Float32Array> {
-    readonly parseTypedArray: typeof parseFloat32Array;
-}
+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>;
+/** @deprecated Use createTypedArrayLoaderClass instead. */
+export declare const Int16ArrayLoader: Class<TypedArrayLoader<Int16Array>>;
+/** @deprecated Use createTypedArrayLoaderClass instead. */
+export declare const Uint16ArrayLoader: Class<TypedArrayLoader<Uint16Array>>;
+/** @deprecated Use createTypedArrayLoaderClass instead. */
+export declare const Float32ArrayLoader: Class<TypedArrayLoader<Float32Array>>;

package/types/index.d.ts

@@ -15,4 +15,5 @@ export * from './TileCoordinate';
 export * from './TilingScheme';
 export * from './typedArray';
 export * from './TypedArrayLoader';
+export * from './typedArrayParsers';
 export * from './types';

package/types/math.d.ts

@@ -8,6 +8,7 @@ export declare const isPowerOfTwo: typeof import('three/src/math/MathUtils.js').
 export declare const ceilPowerOfTwo: typeof import('three/src/math/MathUtils.js').ceilPowerOfTwo;
 export declare const floorPowerOfTwo: typeof import('three/src/math/MathUtils.js').floorPowerOfTwo;
 export declare const normalize: typeof import('three/src/math/MathUtils.js').normalize;
+export declare const remap: typeof import('three/src/math/MathUtils.js').mapLinear;
 export declare function smoothstep(min: number, max: number, x: number): number;
 export declare function saturate(x: number): number;
 export declare function closeTo(a: number, b: number, relativeEpsilon: number, absoluteEpsilon?: number): boolean;

package/types/typedArray.d.ts

@@ -1,10 +1,4 @@
 export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
 export type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
-type GetValue = keyof {
-    [K in keyof DataView as DataView[K] extends (byteOffset: number) => number ? K : never]: DataView[K];
-};
-export declare function parseTypedArray<T extends TypedArrayConstructor, K extends GetValue>(buffer: ArrayBuffer, TypedArray: T, getValue: K, littleEndian?: boolean): InstanceType<T>;
-export declare function parseInt16Array(buffer: ArrayBuffer, littleEndian?: boolean): Int16Array;
-export declare function parseUint16Array(buffer: ArrayBuffer, littleEndian?: boolean): Uint16Array;
-export declare function parseFloat32Array(buffer: ArrayBuffer, littleEndian?: boolean): Float32Array;
-export {};
+export type TypedArrayElementType = 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32' | 'float32' | 'float64';
+export declare function getTypedArrayElementType(array: TypedArray): TypedArrayElementType;

package/types/typedArrayParsers.d.ts

@@ -0,0 +1,11 @@
+import { TypedArray } from './typedArray';
+
+export type TypedArrayParser<T extends TypedArray> = (buffer: ArrayBuffer, littleEndian?: boolean) => T;
+export declare const parseUint8Array: TypedArrayParser<Uint8Array>;
+export declare const parseInt8Array: TypedArrayParser<Int8Array>;
+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 parseFloat32Array: TypedArrayParser<Float32Array>;
+export declare const parseFloat64Array: TypedArrayParser<Float64Array>;