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

package/src/shaders/poissonDisk.glsl

@@ -0,0 +1,21 @@
+// 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)

package/src/shaders/raySphereIntersection.glsl

@@ -0,0 +1,134 @@
+float raySphereFirstIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  return discriminant < 0.0
+    ? -1.0
+    : (-b - sqrt(discriminant)) * 0.5;
+}
+
+float raySphereFirstIntersection(const vec3 origin, const vec3 direction, const float radius) {
+  return raySphereFirstIntersection(origin, direction, vec3(0.0), radius);
+}
+
+vec4 raySphereFirstIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  return mix((-b - sqrt(max(vec4(0.0), discriminant))) * 0.5, vec4(-1.0), mask);
+}
+
+vec4 raySphereFirstIntersection(const vec3 origin, const vec3 direction, const vec4 radius) {
+  return raySphereFirstIntersection(origin, direction, vec3(0.0), radius);
+}
+
+float raySphereSecondIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  return discriminant < 0.0
+    ? -1.0
+    : (-b + sqrt(discriminant)) * 0.5;
+}
+
+float raySphereSecondIntersection(const vec3 origin, const vec3 direction, const float radius) {
+  return raySphereSecondIntersection(origin, direction, vec3(0.0), radius);
+}
+
+vec4 raySphereSecondIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  return mix((-b + sqrt(max(vec4(0.0), discriminant))) * 0.5, vec4(-1.0), mask);
+}
+
+vec4 raySphereSecondIntersection(const vec3 origin, const vec3 direction, const vec4 radius) {
+  return raySphereSecondIntersection(origin, direction, vec3(0.0), radius);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius,
+  out float intersection1,
+  out float intersection2
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  if (discriminant < 0.0) {
+    intersection1 = -1.0;
+    intersection2 = -1.0;
+    return;
+  } else {
+    float Q = sqrt(discriminant);
+    intersection1 = (-b - Q) * 0.5;
+    intersection2 = (-b + Q) * 0.5;
+  }
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const float radius,
+  out float intersection1,
+  out float intersection2
+) {
+  raySphereIntersections(origin, direction, vec3(0.0), radius, intersection1, intersection2);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius,
+  out vec4 intersection1,
+  out vec4 intersection2
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  vec4 Q = sqrt(max(vec4(0.0), discriminant));
+  intersection1 = mix((-b - Q) * 0.5, vec4(-1.0), mask);
+  intersection2 = mix((-b + Q) * 0.5, vec4(-1.0), mask);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec4 radius,
+  out vec4 intersection1,
+  out vec4 intersection2
+) {
+  raySphereIntersections(origin, direction, vec3(0.0), radius, intersection1, intersection2);
+}

package/src/shaders/turbo.glsl

@@ -0,0 +1,9 @@
+// A fifth-order polynomial approximation of Turbo color map.
+// See: https://observablehq.com/@mbostock/turbo
+// prettier-ignore
+vec3 turbo(const float x) {
+  float r = 0.1357 + x * (4.5974 - x * (42.3277 - x * (130.5887 - x * (150.5666 - x * 58.1375))));
+  float g = 0.0914 + x * (2.1856 + x * (4.8052 - x * (14.0195 - x * (4.2109 + x * 2.7747))));
+  float b = 0.1067 + x * (12.5925 - x * (60.1097 - x * (109.0745 - x * (88.5066 - x * 26.8183))));
+  return vec3(r, g, b);
+}

package/src/types.ts

@@ -1,54 +1,8 @@
-import {
-  type Matrix2,
-  type Matrix3,
-  type Matrix4,
-  type Vector2,
-  type Vector3,
-  type Vector4
-} from 'three'
-import { type ReadonlyTuple } from 'type-fest'
+import { type Uniform } from 'three'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Callable = (...args: any) => any
 
-export type ReadonlyTuple2<T = number> = ReadonlyTuple<T, 2>
-export type ReadonlyTuple3<T = number> = ReadonlyTuple<T, 3>
-export type ReadonlyTuple4<T = number> = ReadonlyTuple<T, 4>
-
-// Non-readonly version of ReadonlyTuple. This is not type-safe because mutable
-// methods still exist in the type.
-// See https://github.com/sindresorhus/type-fest/blob/main/source/readonly-tuple.d.ts
-type BuildTupleHelper<
-  Element,
-  Length extends number,
-  Rest extends Element[]
-> = Rest['length'] extends Length
-  ? [...Rest]
-  : BuildTupleHelper<Element, Length, [Element, ...Rest]>
-
-export type Tuple<T, Length extends number> = number extends Length
-  ? readonly T[]
-  : BuildTupleHelper<T, Length, []>
-
-export type Tuple2<T = number> = BuildTupleHelper<T, 2, []>
-export type Tuple3<T = number> = BuildTupleHelper<T, 3, []>
-export type Tuple4<T = number> = BuildTupleHelper<T, 4, []>
-
-// Suppose return type of the mutable methods of classes like Vector3 is `this`.
-// TODO: How can we specify `this` as a constraint?
-type ReadonlyThreeInstance<T> = Readonly<{
-  [K in keyof T as T[K] extends Callable
-    ? ReturnType<T[K]> extends T
-      ? K extends 'clone'
-        ? K
-        : never
-      : K
-    : K]: T[K]
-}>
-
-export type ReadonlyVector2 = ReadonlyThreeInstance<Vector2>
-export type ReadonlyVector3 = ReadonlyThreeInstance<Vector3>
-export type ReadonlyVector4 = ReadonlyThreeInstance<Vector4>
-export type ReadonlyMatrix2 = ReadonlyThreeInstance<Matrix2>
-export type ReadonlyMatrix3 = ReadonlyThreeInstance<Matrix3>
-export type ReadonlyMatrix4 = ReadonlyThreeInstance<Matrix4>
+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
+}

package/src/unrollLoops.ts

@@ -0,0 +1,23 @@
+// Based on: https://github.com/mrdoob/three.js/blob/r170/src/renderers/webgl/WebGLProgram.js#L294
+
+const unrollLoopPattern =
+  /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*(?:i\s*\+\+|\+\+\s*i)\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g
+
+function loopReplacer(
+  match: string,
+  start: string,
+  end: string,
+  snippet: string
+): string {
+  let string = ''
+  for (let i = parseInt(start); i < parseInt(end); ++i) {
+    string += snippet
+      .replace(/\[\s*i\s*\]/g, '[' + i + ']')
+      .replace(/UNROLLED_LOOP_INDEX/g, `${i}`)
+  }
+  return string
+}
+
+export function unrollLoops(string: string): string {
+  return string.replace(unrollLoopPattern, loopReplacer)
+}

package/types/DataLoader.d.ts

@@ -27,11 +27,11 @@ export declare function createDataTextureLoaderClass<T extends TypedArray>(parse
 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>>;
+export declare const Int16Data2DLoader: Class<DataLoader<DataTexture, Int16Array<ArrayBufferLike>>>;
 /** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Uint16Data2DLoader: Class<DataLoader<DataTexture, Uint16Array>>;
+export declare const Uint16Data2DLoader: Class<DataLoader<DataTexture, Uint16Array<ArrayBufferLike>>>;
 /** @deprecated Use createDataTextureLoaderClass instead. */
-export declare const Float32Data2DLoader: Class<DataLoader<DataTexture, Float32Array>>;
+export declare const Float32Data2DLoader: Class<DataLoader<DataTexture, Float32Array<ArrayBufferLike>>>;
 /** @deprecated Use createData3DTextureLoaderClass instead. */
-export declare const Float32Data3DLoader: Class<DataLoader<Data3DTexture, Float32Array>>;
+export declare const Float32Data3DLoader: Class<DataLoader<Data3DTexture, Float32Array<ArrayBufferLike>>>;
 export {};

package/types/Texture3DLoader.d.ts

@@ -0,0 +1,5 @@
+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;
+}

package/types/TypedArrayLoader.d.ts

@@ -9,8 +9,8 @@ export declare abstract class TypedArrayLoader<T extends TypedArray> extends Loa
 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>>;
+export declare const Int16ArrayLoader: Class<TypedArrayLoader<Int16Array<ArrayBufferLike>>>;
 /** @deprecated Use createTypedArrayLoaderClass instead. */
-export declare const Uint16ArrayLoader: Class<TypedArrayLoader<Uint16Array>>;
+export declare const Uint16ArrayLoader: Class<TypedArrayLoader<Uint16Array<ArrayBufferLike>>>;
 /** @deprecated Use createTypedArrayLoaderClass instead. */
-export declare const Float32ArrayLoader: Class<TypedArrayLoader<Float32Array>>;
+export declare const Float32ArrayLoader: Class<TypedArrayLoader<Float32Array<ArrayBufferLike>>>;

package/types/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const STBN_TEXTURE_WIDTH = 128;
+export declare const STBN_TEXTURE_HEIGHT = 128;
+export declare const STBN_TEXTURE_DEPTH = 64;

package/types/index.d.ts

@@ -1,9 +1,7 @@
-export declare const depthShader: string;
-export declare const packingShader: string;
-export declare const transformShader: string;
 export * from './ArrayBufferLoader';
 export * from './assertions';
 export * from './bufferGeometry';
+export * from './constants';
 export * from './DataLoader';
 export * from './Ellipsoid';
 export * from './EllipsoidGeometry';
@@ -11,9 +9,11 @@ export * from './Geodetic';
 export * from './math';
 export * from './PointOfView';
 export * from './Rectangle';
+export * from './resolveIncludes';
 export * from './TileCoordinate';
 export * from './TilingScheme';
 export * from './typedArray';
 export * from './TypedArrayLoader';
 export * from './typedArrayParsers';
 export * from './types';
+export * from './unrollLoops';

package/types/r3f/index.d.ts

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

package/types/r3f/types.d.ts

@@ -0,0 +1,22 @@
+import { Callable } from '../types';
+import { WritableKeysOf } from 'type-fest';
+import { Vector2 as Vector2Impl, Vector3 as Vector3Impl, Vector4 as Vector4Impl } from 'three';
+import { Color, ExtendedColors, NodeProps, Overwrite, Vector2, Vector3, Vector4 } from '@react-three/fiber';
+
+export type ExtendedVectors<T> = {
+    [K in keyof T]: Vector2Impl extends T[K] ? Vector2 | T[K] : Vector3Impl extends T[K] ? Vector3 | T[K] : Vector4Impl extends T[K] ? Vector4 | T[K] : T[K];
+};
+export type ExtendedProps<T> = ExtendedColors<ExtendedVectors<T>>;
+type NonFunctionKeys<T> = keyof {
+    [K in keyof T as Callable extends T[K] ? never : K]: any;
+};
+type WritableNonExtendableKeysOf<T> = WritableKeysOf<T> | keyof {
+    [K in keyof T as Vector2Impl extends T[K] ? K : Vector3Impl extends T[K] ? K : Vector4Impl extends T[K] ? K : Color extends T[K] ? K : never]: any;
+};
+export type PassThoughInstanceProps<RefType, Args extends readonly any[], Props> = Overwrite<ExtendedProps<{
+    [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];
+};
+export {};

package/types/resolveIncludes.d.ts

@@ -0,0 +1,5 @@
+interface Includes {
+    [key: string]: string | Includes;
+}
+export declare function resolveIncludes(source: string, includes: Includes): string;
+export {};

package/types/shaders/index.d.ts

@@ -0,0 +1,8 @@
+export declare const depth: string;
+export declare const generators: 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;

package/types/types.d.ts

@@ -1,22 +1,7 @@
-import { ReadonlyTuple } from 'type-fest';
-import { Matrix2, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
+import { Uniform } from 'three';
 
 export type Callable = (...args: any) => any;
-export type ReadonlyTuple2<T = number> = ReadonlyTuple<T, 2>;
-export type ReadonlyTuple3<T = number> = ReadonlyTuple<T, 3>;
-export type ReadonlyTuple4<T = number> = ReadonlyTuple<T, 4>;
-type BuildTupleHelper<Element, Length extends number, Rest extends Element[]> = Rest['length'] extends Length ? [...Rest] : BuildTupleHelper<Element, Length, [Element, ...Rest]>;
-export type Tuple<T, Length extends number> = number extends Length ? readonly T[] : BuildTupleHelper<T, Length, []>;
-export type Tuple2<T = number> = BuildTupleHelper<T, 2, []>;
-export type Tuple3<T = number> = BuildTupleHelper<T, 3, []>;
-export type Tuple4<T = number> = BuildTupleHelper<T, 4, []>;
-type ReadonlyThreeInstance<T> = Readonly<{
-    [K in keyof T as T[K] extends Callable ? ReturnType<T[K]> extends T ? K extends 'clone' ? K : never : K : K]: T[K];
-}>;
-export type ReadonlyVector2 = ReadonlyThreeInstance<Vector2>;
-export type ReadonlyVector3 = ReadonlyThreeInstance<Vector3>;
-export type ReadonlyVector4 = ReadonlyThreeInstance<Vector4>;
-export type ReadonlyMatrix2 = ReadonlyThreeInstance<Matrix2>;
-export type ReadonlyMatrix3 = ReadonlyThreeInstance<Matrix3>;
-export type ReadonlyMatrix4 = ReadonlyThreeInstance<Matrix4>;
-export {};
+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;
+};

package/types/unrollLoops.d.ts

@@ -0,0 +1 @@
+export declare function unrollLoops(string: string): string;