@takram/three-geospatial 0.0.1-alpha.1

package/types/DataLoader.d.ts

@@ -0,0 +1,67 @@
+import { Callable } from './types';
+import { Float32ArrayLoader, Int16ArrayLoader, Uint16ArrayLoader, TypedArrayLoader } from './TypedArrayLoader';
+import { Class } from 'type-fest';
+import { Data3DTexture, DataTexture, Loader, Texture, TypedArray } from 'three';
+
+export interface ImageSize {
+    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> {
+    abstract readonly Texture: Class<T>;
+    abstract readonly TypedArrayLoader: Class<TypedArrayLoader<U>>;
+    readonly parameters?: DataTextureParameters;
+    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;
+    };
+}

package/types/Ellipsoid.d.ts

@@ -0,0 +1,18 @@
+import { ProjectOnEllipsoidSurfaceOptions } from './helpers/projectOnEllipsoidSurface';
+import { Matrix4, Vector3, Ray } from 'three';
+
+export declare class Ellipsoid {
+    static readonly WGS84: Ellipsoid;
+    readonly radii: Vector3;
+    constructor(x: number, y: number, z: number);
+    get minimumRadius(): number;
+    get maximumRadius(): number;
+    reciprocalRadii(result?: Vector3): Vector3;
+    reciprocalRadiiSquared(result?: Vector3): Vector3;
+    projectOnSurface(position: Vector3, result?: Vector3, options?: ProjectOnEllipsoidSurfaceOptions): Vector3 | undefined;
+    getSurfaceNormal(position: Vector3, result?: Vector3): Vector3;
+    getEastNorthUpVectors(position: Vector3, east?: Vector3, north?: Vector3, up?: Vector3): void;
+    getEastNorthUpFrame(position: Vector3, result?: Matrix4): Matrix4;
+    getIntersection(ray: Ray, result?: Vector3): Vector3 | undefined;
+    getOsculatingSphereCenter(surfacePosition: Vector3, radius: number, result?: Vector3): Vector3;
+}

package/types/EllipsoidGeometry.d.ts

@@ -0,0 +1,13 @@
+import { BufferGeometry, Vector3 } from 'three';
+
+export interface EllipsoidGeometryParameters {
+    radii: Vector3;
+    longitudeSegments?: number;
+    latitudeSegments?: number;
+}
+export declare class EllipsoidGeometry extends BufferGeometry {
+    readonly type = "EllipsoidGeometry";
+    parameters: EllipsoidGeometryParameters;
+    constructor(radii?: Vector3, longitudeSegments?: number, latitudeSegments?: number);
+    copy(source: EllipsoidGeometry): this;
+}

package/types/Geodetic.d.ts

@@ -0,0 +1,37 @@
+import { ProjectOnEllipsoidSurfaceOptions } from './helpers/projectOnEllipsoidSurface';
+import { Ellipsoid } from './Ellipsoid';
+import { Vector3 } from 'three';
+
+export type GeodeticTuple = [number, number, number];
+export interface GeodeticLike {
+    readonly longitude: number;
+    readonly latitude: number;
+    readonly height: number;
+}
+export declare class Geodetic {
+    longitude: number;
+    latitude: number;
+    height: number;
+    static readonly MIN_LONGITUDE: number;
+    static readonly MAX_LONGITUDE: number;
+    static readonly MIN_LATITUDE: number;
+    static readonly MAX_LATITUDE: number;
+    constructor(longitude?: number, latitude?: number, height?: number);
+    set(longitude: number, latitude: number, height?: number): this;
+    clone(): Geodetic;
+    copy(other: GeodeticLike): this;
+    equals(other: GeodeticLike): boolean;
+    setLongitude(value: number): this;
+    setLatitude(value: number): this;
+    setHeight(value: number): this;
+    normalize(): this;
+    setFromECEF(position: Vector3, options?: ProjectOnEllipsoidSurfaceOptions & {
+        ellipsoid?: Ellipsoid;
+    }): this;
+    toECEF(result?: Vector3, options?: {
+        ellipsoid?: Ellipsoid;
+    }): Vector3;
+    fromArray(array: readonly number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    [Symbol.iterator](): Generator<number>;
+}

package/types/PointOfView.d.ts

@@ -0,0 +1,20 @@
+import { Ellipsoid } from './Ellipsoid';
+import { Quaternion, Vector3, Camera } from 'three';
+
+export declare class PointOfView {
+    private _distance;
+    heading: number;
+    private _pitch;
+    roll: number;
+    constructor(distance?: number, heading?: number, pitch?: number, roll?: number);
+    get distance(): number;
+    set distance(value: number);
+    get pitch(): number;
+    set pitch(value: number);
+    set(distance: number, heading: number, pitch: number, roll?: number): this;
+    clone(): PointOfView;
+    copy(other: PointOfView): this;
+    equals(other: PointOfView): boolean;
+    decompose(target: Vector3, eye: Vector3, quaternion: Quaternion, up?: Vector3, ellipsoid?: Ellipsoid): void;
+    setFromCamera(camera: Camera, ellipsoid?: Ellipsoid): this | undefined;
+}

package/types/Rectangle.d.ts

@@ -0,0 +1,27 @@
+import { Geodetic } from './Geodetic';
+
+export type RectangleTuple = [number, number, number, number];
+export interface RectangleLike {
+    readonly west: number;
+    readonly south: number;
+    readonly east: number;
+    readonly north: number;
+}
+export declare class Rectangle {
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+    static readonly MAX: Rectangle;
+    constructor(west?: number, south?: number, east?: number, north?: number);
+    get width(): number;
+    get height(): number;
+    set(west: number, south: number, east: number, north: number): this;
+    clone(): Rectangle;
+    copy(other: RectangleLike): this;
+    equals(other: RectangleLike): boolean;
+    at(x: number, y: number, result?: Geodetic): Geodetic;
+    fromArray(array: readonly number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    [Symbol.iterator](): Generator<number>;
+}

package/types/TileCoordinate.d.ts

@@ -0,0 +1,21 @@
+export type TileCoordinateTuple = [number, number, number];
+export interface TileCoordinateLike {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+export declare class TileCoordinate {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    set(x: number, y: number, z?: number): this;
+    clone(): TileCoordinate;
+    copy(other: TileCoordinateLike): this;
+    equals(other: TileCoordinateLike): boolean;
+    getParent(result?: TileCoordinate): TileCoordinate;
+    traverseChildren(depth: number, result?: TileCoordinate): Generator<TileCoordinate>;
+    fromArray(array: readonly number[], offset?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    [Symbol.iterator](): Generator<number>;
+}

package/types/TilingScheme.d.ts

@@ -0,0 +1,21 @@
+import { TileCoordinate, TileCoordinateLike } from './TileCoordinate';
+import { Rectangle, RectangleLike } from './Rectangle';
+import { GeodeticLike } from './Geodetic';
+import { Vector2 } from 'three';
+
+export interface TilingSchemeLike {
+    readonly width: number;
+    readonly height: number;
+    readonly rectangle: RectangleLike;
+}
+export declare class TilingScheme {
+    width: number;
+    height: number;
+    rectangle: Rectangle;
+    constructor(width?: number, height?: number, rectangle?: Rectangle);
+    clone(): TilingScheme;
+    copy(other: TilingSchemeLike): this;
+    getSize(z: number, result?: Vector2): Vector2;
+    getTile(geodetic: GeodeticLike, z: number, result?: TileCoordinate): TileCoordinate;
+    getRectangle(tile: TileCoordinateLike, result?: Rectangle): Rectangle;
+}

package/types/TypedArrayLoader.d.ts

@@ -0,0 +1,16 @@
+import { parseFloat32Array, parseInt16Array, parseUint16Array } from './typedArray';
+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;
+}

package/types/assertions.d.ts

@@ -0,0 +1,4 @@
+export declare function assertType<T>(value: unknown): asserts value is T;
+export declare function isNotNullish<T>(value: T | null | undefined): value is T;
+export declare function isNotUndefined<T>(value: T | undefined): value is T;
+export declare function isNotFalse<T>(value: T | false): value is T;

package/types/bufferGeometry.d.ts

@@ -0,0 +1,5 @@
+import { BufferGeometry } from 'three';
+
+export type BufferGeometryLike = 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/helpers/projectOnEllipsoidSurface.d.ts

@@ -0,0 +1,6 @@
+import { Vector3 } from 'three';
+
+export interface ProjectOnEllipsoidSurfaceOptions {
+    centerTolerance?: number;
+}
+export declare function projectOnEllipsoidSurface(position: Vector3, reciprocalRadiiSquared: Vector3, result?: Vector3, options?: ProjectOnEllipsoidSurfaceOptions): Vector3 | undefined;

package/types/index.d.ts

@@ -0,0 +1,18 @@
+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 './DataLoader';
+export * from './Ellipsoid';
+export * from './EllipsoidGeometry';
+export * from './Geodetic';
+export * from './math';
+export * from './PointOfView';
+export * from './Rectangle';
+export * from './TileCoordinate';
+export * from './TilingScheme';
+export * from './typedArray';
+export * from './TypedArrayLoader';
+export * from './types';

package/types/math.d.ts

@@ -0,0 +1,13 @@
+export declare const clamp: typeof import('three/src/math/MathUtils.js').clamp;
+export declare const euclideanModulo: typeof import('three/src/math/MathUtils.js').euclideanModulo;
+export declare const inverseLerp: typeof import('three/src/math/MathUtils.js').inverseLerp;
+export declare const lerp: typeof import('three/src/math/MathUtils.js').lerp;
+export declare const radians: typeof import('three/src/math/MathUtils.js').degToRad;
+export declare const degrees: typeof import('three/src/math/MathUtils.js').radToDeg;
+export declare const isPowerOfTwo: typeof import('three/src/math/MathUtils.js').isPowerOfTwo;
+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 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/r3f/EastNorthUpFrame.d.ts

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

package/types/r3f/EllipsoidMesh.d.ts

@@ -0,0 +1,13 @@
+import { EllipsoidGeometry } from '../EllipsoidGeometry';
+import { Mesh } from 'three';
+import { BufferGeometryNode, MeshProps } from '@react-three/fiber';
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        ellipsoidGeometry: BufferGeometryNode<EllipsoidGeometry, typeof EllipsoidGeometry>;
+    }
+}
+export interface EllipsoidMeshProps extends Omit<MeshProps, '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>>>;

package/types/r3f/index.d.ts

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

package/types/typedArray.d.ts

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

package/types/types.d.ts

@@ -0,0 +1,22 @@
+import { ReadonlyTuple } from 'type-fest';
+import { Matrix2, Matrix3, Matrix4, Vector2, Vector3, Vector4 } 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 {};