@takram/three-geospatial 0.0.1-alpha.7 → 0.0.1-alpha.9

package/src/TilingScheme.ts

@@ -42,17 +42,19 @@ export class TilingScheme {
     result = new TileCoordinate()
   ): TileCoordinate {
     const size = this.getSize(z, vectorScratch)
-    const width = this.rectangle.width / size.x
-    const height = this.rectangle.height / size.y
+    const { rectangle } = this
+    const width = rectangle.width / size.x
+    const height = rectangle.height / size.y
+    const { west, south, east } = rectangle
     let longitude = geodetic.longitude
-    if (this.rectangle.east < this.rectangle.west) {
+    if (east < west) {
       longitude += Math.PI * 2
     }
-    let x = Math.floor((longitude - this.rectangle.west) / width)
+    let x = Math.floor((longitude - west) / width)
     if (x >= size.x) {
       x = size.x - 1
     }
-    let y = Math.floor((geodetic.latitude - this.rectangle.south) / height)
+    let y = Math.floor((geodetic.latitude - south) / height)
     if (y >= size.y) {
       y = size.y - 1
     }
@@ -65,12 +67,14 @@ export class TilingScheme {
   // Reference: https://github.com/CesiumGS/cesium/blob/1.122/packages/engine/Source/Core/GeographicTilingScheme.js#L169
   getRectangle(tile: TileCoordinateLike, result = new Rectangle()): Rectangle {
     const size = this.getSize(tile.z, vectorScratch)
-    const width = this.rectangle.width / size.x
-    const height = this.rectangle.height / size.y
-    result.west = tile.x * width + this.rectangle.west
-    result.east = (tile.x + 1) * width + this.rectangle.west
-    result.north = this.rectangle.north - (size.y - tile.y - 1) * height
-    result.south = this.rectangle.north - (size.y - tile.y) * height
+    const { rectangle } = this
+    const width = rectangle.width / size.x
+    const height = rectangle.height / size.y
+    const { west, north } = rectangle
+    result.west = tile.x * width + west
+    result.east = (tile.x + 1) * width + west
+    result.north = north - (size.y - tile.y - 1) * height
+    result.south = north - (size.y - tile.y) * height
     return result
   }
 }

package/src/TypedArrayLoader.ts

@@ -1,7 +1,8 @@
-import { Loader, type TypedArray } from 'three'
+import { Loader } from 'three'
 import { type Class } from 'type-fest'
 
 import { ArrayBufferLoader } from './ArrayBufferLoader'
+import { type TypedArray } from './typedArray'
 import {
   parseFloat32Array,
   parseInt16Array,

package/src/bufferGeometry.ts

@@ -1,9 +1,10 @@
 import { Box3, BufferAttribute, BufferGeometry, Sphere, Vector3 } from 'three'
 
-export type BufferGeometryLike = Pick<
-  BufferGeometry,
-  'attributes' | 'index' | 'boundingBox' | 'boundingSphere'
->
+export interface BufferGeometryLike
+  extends Pick<
+    BufferGeometry,
+    'attributes' | 'index' | 'boundingBox' | 'boundingSphere'
+  > {}
 
 export function toBufferGeometryLike(
   geometry: BufferGeometry

package/src/decorators.ts

@@ -0,0 +1,207 @@
+import { Material } from 'three'
+
+import { clamp } from './math'
+
+interface EffectLike {
+  defines: Map<string, string>
+}
+
+export function define(name: string) {
+  return <T extends Material | EffectLike, K extends keyof T>(
+    target: T[K] extends boolean ? T : never,
+    propertyKey: K
+  ) => {
+    if (target instanceof Material) {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, Material>): boolean {
+          return this.defines?.[name] != null
+        },
+        set(this: Extract<T, Material>, value: boolean) {
+          if (value !== this[propertyKey]) {
+            if (value) {
+              this.defines ??= {}
+              this.defines[name] = '1'
+            } else {
+              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+              delete this.defines?.[name]
+            }
+            this.needsUpdate = true
+          }
+        }
+      })
+    } else {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, EffectLike>): boolean {
+          return this.defines.has(name)
+        },
+        set(this: Extract<T, EffectLike>, value: boolean) {
+          if (value !== this[propertyKey]) {
+            if (value) {
+              this.defines.set(name, '1')
+            } else {
+              this.defines.delete(name)
+            }
+            ;(this as any).setChanged() // Bypass protected privilege
+          }
+        }
+      })
+    }
+  }
+}
+
+export interface DefineIntDecoratorOptions {
+  min?: number
+  max?: number
+}
+
+export function defineInt(
+  name: string,
+  {
+    min = Number.MIN_SAFE_INTEGER,
+    max = Number.MAX_SAFE_INTEGER
+  }: DefineIntDecoratorOptions = {}
+) {
+  return <T extends Material | EffectLike, K extends keyof T>(
+    target: T[K] extends number ? T : never,
+    propertyKey: K
+  ) => {
+    if (target instanceof Material) {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, Material>): number {
+          const value = this.defines?.[name]
+          return value != null ? parseInt(value) : 0
+        },
+        set(this: Extract<T, Material>, value: number) {
+          const prevValue = this[propertyKey]
+          if (value !== prevValue) {
+            this.defines ??= {}
+            this.defines[name] = clamp(value, min, max).toFixed(0)
+            this.needsUpdate = true
+          }
+        }
+      })
+    } else {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, EffectLike>): number {
+          const value = this.defines.get(name)
+          return value != null ? parseInt(value) : 0
+        },
+        set(this: Extract<T, EffectLike>, value: number) {
+          const prevValue = this[propertyKey]
+          if (value !== prevValue) {
+            this.defines.set(name, clamp(value, min, max).toFixed(0))
+            ;(this as any).setChanged() // Bypass protected privilege
+          }
+        }
+      })
+    }
+  }
+}
+
+export interface DefineFloatDecoratorOptions {
+  min?: number
+  max?: number
+  precision?: number
+}
+
+export function defineFloat(
+  name: string,
+  {
+    min = -Infinity,
+    max = Infinity,
+    precision = 7
+  }: DefineFloatDecoratorOptions = {}
+) {
+  return <T extends Material | EffectLike, K extends keyof T>(
+    target: T[K] extends number ? T : never,
+    propertyKey: K
+  ) => {
+    if (target instanceof Material) {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, Material>): number {
+          const value = this.defines?.[name]
+          return value != null ? parseFloat(value) : 0
+        },
+        set(this: Extract<T, Material>, value: number) {
+          const prevValue = this[propertyKey]
+          if (value !== prevValue) {
+            this.defines ??= {}
+            this.defines[name] = clamp(value, min, max).toFixed(precision)
+            this.needsUpdate = true
+          }
+        }
+      })
+    } else {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, EffectLike>): number {
+          const value = this.defines.get(name)
+          return value != null ? parseFloat(value) : 0
+        },
+        set(this: Extract<T, EffectLike>, value: number) {
+          const prevValue = this[propertyKey]
+          if (value !== prevValue) {
+            this.defines.set(name, clamp(value, min, max).toFixed(precision))
+            ;(this as any).setChanged() // Bypass protected privilege
+          }
+        }
+      })
+    }
+  }
+}
+
+export interface DefineExpressionDecoratorOptions {
+  validate?: (value: string) => boolean
+}
+
+export function defineExpression(
+  name: string,
+  { validate }: DefineExpressionDecoratorOptions = {}
+) {
+  return <T extends Material | EffectLike, K extends keyof T>(
+    target: T[K] extends string ? T : never,
+    propertyKey: K
+  ) => {
+    if (target instanceof Material) {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, Material>): string {
+          return this.defines?.[name] ?? ''
+        },
+        set(this: Extract<T, Material>, value: string) {
+          if (value !== this[propertyKey]) {
+            if (validate?.(value) === false) {
+              console.error(`Expression validation failed: ${value}`)
+              return
+            }
+            this.defines ??= {}
+            this.defines[name] = value
+            this.needsUpdate = true
+          }
+        }
+      })
+    } else {
+      Object.defineProperty(target, propertyKey, {
+        enumerable: true,
+        get(this: Extract<T, EffectLike>): string {
+          return this.defines.get(name) ?? ''
+        },
+        set(this: Extract<T, EffectLike>, value: string) {
+          if (value !== this[propertyKey]) {
+            if (validate?.(value) === false) {
+              console.error(`Expression validation failed: ${value}`)
+              return
+            }
+            this.defines.set(name, value)
+            ;(this as any).setChanged() // Bypass protected privilege
+          }
+        }
+      })
+    }
+  }
+}

package/src/index.ts

@@ -3,9 +3,11 @@ export * from './assertions'
 export * from './bufferGeometry'
 export * from './constants'
 export * from './DataLoader'
+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/r3f/types.ts

@@ -59,5 +59,7 @@ export type PassThoughInstanceProps<
 >
 
 export type ExpandNestedProps<T, Prop extends keyof T & string> = {
-  [K in keyof T[Prop] as K extends string ? `${Prop}-${K}` : never]: T[Prop][K]
+  [K in keyof NonNullable<T[Prop]> as K extends string
+    ? `${Prop}-${K}`
+    : 'never']: NonNullable<T[Prop]>[K]
 }

package/src/shaders/index.ts

@@ -1,19 +1,21 @@
 import _cascadedShadowMaps from './cascadedShadowMaps.glsl?raw'
 import _depth from './depth.glsl?raw'
 import _generators from './generators.glsl?raw'
+import _interleavedGradientNoise from './interleavedGradientNoise.glsl?raw'
 import _math from './math.glsl?raw'
 import _packing from './packing.glsl?raw'
-import _poissonDisk from './poissonDisk.glsl?raw'
 import _raySphereIntersection from './raySphereIntersection.glsl?raw'
 import _transform from './transform.glsl?raw'
 import _turbo from './turbo.glsl?raw'
+import _vogelDisk from './vogelDisk.glsl?raw'
 
 export const cascadedShadowMaps: string = _cascadedShadowMaps
 export const depth: string = _depth
 export const generators: string = _generators
+export const interleavedGradientNoise = _interleavedGradientNoise
 export const math: string = _math
 export const packing: string = _packing
-export const poissonDisk: string = _poissonDisk
 export const raySphereIntersection: string = _raySphereIntersection
 export const transform: string = _transform
 export const turbo: string = _turbo
+export const vogelDisk = _vogelDisk

package/src/shaders/interleavedGradientNoise.glsl

@@ -0,0 +1,6 @@
+// Reference: https://advances.realtimerendering.com/s2014/index.html#_NEXT_GENERATION_POST
+
+float interleavedGradientNoise(const vec2 coord) {
+  const vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);
+  return fract(magic.z * fract(dot(coord, magic.xy)));
+}

package/src/shaders/vogelDisk.glsl

@@ -0,0 +1,8 @@
+// Reference: https://www.gamedev.net/tutorials/programming/graphics/contact-hardening-soft-shadows-made-fast-r4906/
+
+vec2 vogelDisk(const int index, const int sampleCount, const float phi) {
+  const float goldenAngle = 2.39996322972865332;
+  float r = sqrt(float(index) + 0.5) / sqrt(float(sampleCount));
+  float theta = float(index) * goldenAngle + phi;
+  return r * vec2(cos(theta), sin(theta));
+}

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,21 +1,22 @@
 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];
 };
-export type DataTextureParameters = Omit<Partial<ParameterProperties<DataTexture>>, 'image'> & {
+export interface DataTextureParameters extends Omit<Partial<ParameterProperties<DataTexture>>, 'image'> {
     width?: number;
     height?: number;
-};
-export type Data3DTextureParameters = Omit<Partial<ParameterProperties<Data3DTexture>>, 'image'> & {
+}
+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>>;
@@ -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/bufferGeometry.d.ts

@@ -1,5 +1,6 @@
 import { BufferGeometry } from 'three';
 
-export type BufferGeometryLike = Pick<BufferGeometry, 'attributes' | 'index' | 'boundingBox' | 'boundingSphere'>;
+export interface BufferGeometryLike extends Pick<BufferGeometry, 'attributes' | 'index' | 'boundingBox' | 'boundingSphere'> {
+}
 export declare function toBufferGeometryLike(geometry: BufferGeometry): [BufferGeometryLike, ArrayBuffer[]];
 export declare function fromBufferGeometryLike(input: BufferGeometryLike, result?: BufferGeometry<import('three').NormalBufferAttributes>): BufferGeometry;

package/types/decorators.d.ts

@@ -0,0 +1,22 @@
+import { Material } from 'three';
+
+interface EffectLike {
+    defines: Map<string, string>;
+}
+export declare function define(name: string): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends boolean ? T : never, propertyKey: K) => void;
+export interface DefineIntDecoratorOptions {
+    min?: number;
+    max?: number;
+}
+export declare function defineInt(name: string, { min, max }?: DefineIntDecoratorOptions): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends number ? T : never, propertyKey: K) => void;
+export interface DefineFloatDecoratorOptions {
+    min?: number;
+    max?: number;
+    precision?: number;
+}
+export declare function defineFloat(name: string, { min, max, precision }?: DefineFloatDecoratorOptions): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends number ? T : never, propertyKey: K) => void;
+export interface DefineExpressionDecoratorOptions {
+    validate?: (value: string) => boolean;
+}
+export declare function defineExpression(name: string, { validate }?: DefineExpressionDecoratorOptions): <T extends Material | EffectLike, K extends keyof T>(target: T[K] extends string ? T : never, propertyKey: K) => void;
+export {};

package/types/index.d.ts

@@ -3,9 +3,11 @@ export * from './assertions';
 export * from './bufferGeometry';
 export * from './constants';
 export * from './DataLoader';
+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/r3f/types.d.ts

@@ -16,6 +16,6 @@ export type PassThoughInstanceProps<RefType, Args extends readonly any[], Props>
     [K in NonFunctionKeys<Props> as K extends WritableNonExtendableKeysOf<Props> ? K : never]: Props[K];
 }>, NodeProps<RefType, Args>>;
 export type ExpandNestedProps<T, Prop extends keyof T & string> = {
-    [K in keyof T[Prop] as K extends string ? `${Prop}-${K}` : never]: T[Prop][K];
+    [K in keyof NonNullable<T[Prop]> as K extends string ? `${Prop}-${K}` : 'never']: NonNullable<T[Prop]>[K];
 };
 export {};

package/types/shaders/index.d.ts

@@ -1,9 +1,10 @@
 export declare const cascadedShadowMaps: string;
 export declare const depth: string;
 export declare const generators: string;
+export declare const interleavedGradientNoise: string;
 export declare const math: string;
 export declare const packing: string;
-export declare const poissonDisk: string;
 export declare const raySphereIntersection: string;
 export declare const transform: string;
 export declare const turbo: string;
+export declare const vogelDisk: string;

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>;

package/src/shaders/poissonDisk.glsl

@@ -1,23 +0,0 @@
-// TODO: Maybe switch to Vogel disk with IGN:
-// https://www.gamedev.net/tutorials/programming/graphics/contact-hardening-soft-shadows-made-fast-r4906/
-// Taken from: https://developer.download.nvidia.com/whitepapers/2008/PCSS_Integration.pdf
-const vec2 poissonDisk[16] = vec2[16](
-  vec2(-0.94201624, -0.39906216),
-  vec2(0.94558609, -0.76890725),
-  vec2(-0.094184101, -0.9293887),
-  vec2(0.34495938, 0.2938776),
-  vec2(-0.91588581, 0.45771432),
-  vec2(-0.81544232, -0.87912464),
-  vec2(-0.38277543, 0.27676845),
-  vec2(0.97484398, 0.75648379),
-  vec2(0.44323325, -0.97511554),
-  vec2(0.53742981, -0.4737342),
-  vec2(-0.26496911, -0.41893023),
-  vec2(0.79197514, 0.19090188),
-  vec2(-0.2418884, 0.99706507),
-  vec2(-0.81409955, 0.9143759),
-  vec2(0.19984126, 0.78641367),
-  vec2(0.14383161, -0.1410079)
-);
-
-#define POISSON_DISK_COUNT (16)