maplibre-gl-layers 0.19.0 → 1.1.0

package/dist/host/calculationHost.d.ts

@@ -1,87 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.0
- * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { Map as MapLibreMap } from 'maplibre-gl';
-import { InternalSpriteCurrentState, InternalSpriteImageState, RegisteredImage, ProjectionHost, PreparedDrawSpriteImageParams, RenderCalculationHost, PrepareDrawSpriteImageParamsBefore, PrepareDrawSpriteImageParamsAfter, RenderInterpolationParams, RenderInterpolationResult, SpriteInterpolationEvaluationResult, SpriteInterpolationState } from '../internalTypes';
-import { SpriteLocation, SpritePoint } from '../types';
-import { ProjectionHostParams } from './projectionHost';
-/**
- * Cache entry storing anchor-adjusted and raw centers for a sprite image.
- */
-interface ImageCenterCacheEntry {
-    readonly anchorApplied?: SpritePoint;
-    readonly anchorless?: SpritePoint;
-}
-/**
- * Nested cache keyed by sprite ID and image key to avoid recomputing centers each frame.
- */
-type ImageCenterCache = Map<string, Map<string, ImageCenterCacheEntry>>;
-/**
- * Resolves the image entry that a sprite should use as its origin reference when
- * another image in the same render bucket needs to inherit that origin.
- * The resolver is always invoked with the current sprite/image pair and can
- * return `null` when the origin is not available (e.g., the reference was
- * culled or stored in another bucket).
- */
-type OriginImageResolver<T> = (sprite: Readonly<InternalSpriteCurrentState<T>>, image: Readonly<InternalSpriteImageState>) => InternalSpriteImageState | undefined;
-export declare const DEFAULT_RENDER_INTERPOLATION_RESULT: RenderInterpolationResult;
-interface DepthSortedItem<T> {
-    readonly sprite: InternalSpriteCurrentState<T>;
-    readonly image: InternalSpriteImageState;
-    readonly resource: Readonly<RegisteredImage>;
-    readonly depthKey: number;
-    readonly cameraDistanceMeters: number;
-    readonly distanceScaleFactor: number;
-    readonly resolveOrigin: OriginImageResolver<T>;
-}
-export declare const collectDepthSortedItemsInternal: <T>(projectionHost: ProjectionHost, zoom: number, originCenterCache: ImageCenterCache, { bucket, bucketBuffers, imageResources, resolvedScaling, clipContext, baseMetersPerPixel, drawingBufferWidth, drawingBufferHeight, pixelRatio, }: PrepareDrawSpriteImageParamsBefore<T>) => DepthSortedItem<T>[];
-/**
- * Prepares quad data for a single sprite image before issuing the draw call.
- */
-export declare const prepareDrawSpriteImageInternal: <TTag>(projectionHost: ProjectionHost, item: DepthSortedItem<TTag>, zoom: number, originCenterCache: ImageCenterCache, { imageResources, baseMetersPerPixel, drawingBufferWidth, drawingBufferHeight, pixelRatio, clipContext, identityScaleX, identityScaleY, identityOffsetX, identityOffsetY, screenToClipScaleX, screenToClipScaleY, screenToClipOffsetX, screenToClipOffsetY, }: PrepareDrawSpriteImageParamsAfter) => PreparedDrawSpriteImageParams<TTag> | null;
-export declare const applyVisibilityDistanceLod: <TTag>(preparedItems: readonly PreparedDrawSpriteImageParams<TTag>[]) => void;
-export declare const syncPreparedOpacities: <TTag>(preparedItems: readonly PreparedDrawSpriteImageParams<TTag>[]) => void;
-export declare const filterVisiblePreparedItems: <TTag>(preparedItems: readonly PreparedDrawSpriteImageParams<TTag>[]) => PreparedDrawSpriteImageParams<TTag>[];
-export interface ProcessInterpolationPresetRequests {
-    readonly distance: readonly SpriteInterpolationState<number>[];
-    readonly degree: readonly SpriteInterpolationState<number>[];
-    readonly sprite: readonly SpriteInterpolationState<SpriteLocation>[];
-}
-export interface ProcessInterpolationsEvaluationHandlers {
-    readonly prepare?: (requests: ProcessInterpolationPresetRequests, timestamp: number) => void;
-    readonly evaluateDistance: (states: readonly SpriteInterpolationState<number>[], timestamp: number) => readonly SpriteInterpolationEvaluationResult<number>[];
-    readonly evaluateDegree: (states: readonly SpriteInterpolationState<number>[], timestamp: number) => readonly SpriteInterpolationEvaluationResult<number>[];
-    readonly evaluateSprite: (states: readonly SpriteInterpolationState<SpriteLocation>[], timestamp: number) => readonly SpriteInterpolationEvaluationResult<SpriteLocation>[];
-}
-export declare const processInterpolationsInternal: <TTag>(params: RenderInterpolationParams<TTag>, handlers?: ProcessInterpolationsEvaluationHandlers) => RenderInterpolationResult;
-export declare const processOpacityInterpolationsAfterPreparation: <TTag>(params: RenderInterpolationParams<TTag>, preparedItems: readonly PreparedDrawSpriteImageParams<TTag>[], handlers?: ProcessInterpolationsEvaluationHandlers) => RenderInterpolationResult;
-/**
- * Create calculation host that binding MapLibre.
- * @param TTag Tag type.
- * @param map MapLibre Map.
- * @returns Calculation host.
- */
-export declare const createMapLibreCalculationHost: <TTag>(map: MapLibreMap) => RenderCalculationHost<TTag>;
-/**
- * Create calculation host that pure implementation.
- * @param TTag Tag type.
- * @param params Projection host PrepareDrawSpriteImageInputsparams.
- * @returns Calculation host.
- */
-export declare const createCalculationHost: <TTag>(params: ProjectionHostParams) => RenderCalculationHost<TTag>;
-export declare const __wasmProjectionCalculationTestInternals: {
-    __createWasmProjectionCalculationTestHost: <TTag>(params: ProjectionHostParams) => RenderCalculationHost<TTag>;
-};
-export declare const __calculationHostTestInternals: {
-    applyVisibilityDistanceLod: <TTag>(preparedItems: readonly PreparedDrawSpriteImageParams<TTag>[]) => void;
-    syncPreparedOpacities: <TTag>(preparedItems: readonly PreparedDrawSpriteImageParams<TTag>[]) => void;
-    processOpacityInterpolationsAfterPreparation: <TTag>(params: RenderInterpolationParams<TTag>, preparedItems: readonly PreparedDrawSpriteImageParams<TTag>[], handlers?: ProcessInterpolationsEvaluationHandlers) => RenderInterpolationResult;
-};
-export {};

package/dist/host/mapLibreProjectionHost.d.ts

@@ -1,18 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.0
- * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { Map as MapLibreMap } from 'maplibre-gl';
-import { ProjectionHost } from '../internalTypes';
-/**
- * Create a projection host that delegates to MapLibre.
- * @param map MapLibre map instance
- * @returns Projection host
- */
-export declare const createMapLibreProjectionHost: (map: MapLibreMap) => ProjectionHost;

package/dist/host/projectionHost.d.ts

@@ -1,62 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.0
- * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { mat4 as Mat4 } from 'gl-matrix';
-import { Map as MapLibreMap } from 'maplibre-gl';
-import { SpriteLocation } from '../types';
-import { ClipContext, ProjectionHost } from '../internalTypes';
-/**
- * Required projection parameters. These correspond to the MapLibre transform state.
- */
-export interface ProjectionHostParams {
-    readonly zoom: number;
-    readonly width: number;
-    readonly height: number;
-    readonly center: Readonly<SpriteLocation>;
-    readonly cameraLocation: SpriteLocation | undefined;
-    readonly pitchDeg?: number;
-    readonly bearingDeg?: number;
-    readonly rollDeg?: number;
-    readonly fovDeg?: number;
-    readonly centerElevationMeters?: number;
-    readonly minElevationMeters?: number;
-    readonly cameraToCenterDistance?: number;
-    readonly centerOffsetX?: number;
-    readonly centerOffsetY?: number;
-    readonly tileSize?: number;
-    readonly autoCalculateNearFarZ?: boolean;
-    readonly nearZOverride?: number;
-    readonly farZOverride?: number;
-}
-export interface PreparedProjectionState {
-    readonly zoom: number;
-    readonly mercatorMatrix: Mat4 | undefined;
-    readonly pixelMatrix: Mat4 | undefined;
-    readonly pixelMatrixInverse: Mat4 | undefined;
-    readonly worldSize: number;
-    readonly pixelPerMeter: number;
-    readonly cameraToCenterDistance: number;
-    readonly clipContext: ClipContext | undefined;
-    readonly cameraLocation: SpriteLocation | undefined;
-}
-export declare const prepareProjectionState: (params: ProjectionHostParams) => PreparedProjectionState;
-/**
- * Create a pure calculation projection host.
- * @param params Projection parameters
- * @returns Projection host
- */
-export declare const createProjectionHost: (params: ProjectionHostParams) => ProjectionHost;
-/**
- * Extract current MapLibre transform parameters into {@link ProjectionHostParams}.
- * Falls back to safe defaults when certain transform fields are unavailable.
- * @param map MapLibre map instance.
- * @returns Projection parameters usable by {@link createProjectionHost}.
- */
-export declare const createProjectionHostParamsFromMapLibre: (map: MapLibreMap) => ProjectionHostParams;

package/dist/host/runtime.d.ts

@@ -1,38 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.0
- * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { SpriteLayerCalculationVariant, SpriteLayerHostOptions } from '../types';
-export declare const isSpriteLayerHostEnabled: () => boolean;
-export declare const reportWasmRuntimeFailure: (reason?: unknown) => void;
-/**
- * Initialize maplibre-gl-layers runtime host.
- * @param variantOrOptions Options.
- * @returns Initialized calculation variant.
- */
-export declare const initializeRuntimeHost: (options?: SpriteLayerHostOptions) => Promise<SpriteLayerCalculationVariant>;
-/**
- * Release maplibre-gl-layers runtime host.
- * @returns
- */
-export declare const releaseRuntimeHost: () => void;
-/**
- * SIMD and multi-threading module availability.
- */
-export interface MultiThreadedModuleAvailability {
-    /** Is available? */
-    readonly available: boolean;
-    /** Not available, reason text */
-    readonly reason?: string;
-}
-/**
- * Detects SIMD and multi-threading module availability.
- * @returns MultiThreadedModuleAvailability.
- */
-export declare const detectMultiThreadedModuleAvailability: () => MultiThreadedModuleAvailability;

package/dist/host/wasmCalculationHost.d.ts

@@ -1,72 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.0
- * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { ImageHandleBufferController, IdHandler, InternalSpriteCurrentState, InternalSpriteImageState, PreparedDrawSpriteImageParams, PrepareDrawSpriteImageParams, Releasable, RegisteredImage, RenderCalculationHost, RenderInterpolationParams, RenderInterpolationResult, SpriteOriginReference, SpriteInterpolationEvaluationResult } from '../internalTypes';
-import { SurfaceCorner } from '../utils/math';
-import { SpriteLocation } from '../types';
-import { BufferHolder, WasmHost } from './wasmHost';
-import { ProcessInterpolationPresetRequests } from './calculationHost';
-import { PreparedProjectionState, ProjectionHostParams } from './projectionHost';
-interface WasmProcessInterpolationResults {
-    readonly distance: SpriteInterpolationEvaluationResult<number>[];
-    readonly degree: SpriteInterpolationEvaluationResult<number>[];
-    readonly sprite: SpriteInterpolationEvaluationResult<SpriteLocation>[];
-}
-type CalculateSurfaceDepthKeyOptions = {
-    readonly indices?: readonly number[];
-    readonly bias?: {
-        readonly ndc: number;
-        readonly minClipZEpsilon?: number;
-    };
-};
-export declare const createWasmCalculateSurfaceDepthKey: (preparedState: PreparedProjectionState) => {
-    (baseLngLat: Readonly<SpriteLocation>, displacements: readonly SurfaceCorner[], options?: CalculateSurfaceDepthKeyOptions): number | null;
-    release(): void;
-};
-interface PreparedInputBuffer extends Releasable {
-    readonly parameterHolder: BufferHolder<Float64Array>;
-    readonly resultItemCount: number;
-}
-interface WritableWasmProjectionState<TTag> {
-    readonly preparedProjection: PreparedProjectionState;
-    lastFrameParams?: {
-        baseMetersPerPixel: number;
-        zoomScaleFactor: number;
-    };
-    readonly prepareInputBuffer: (params: PrepareDrawSpriteImageParams<TTag>) => PreparedInputBuffer;
-    readonly getImageRefs: () => readonly InternalSpriteImageState[];
-    readonly getResourceRefs: () => readonly (RegisteredImage | undefined)[];
-}
-/**
- * Wasm interoperability dependencies.
- * @remarks These are a group of helpers that perform marshaling to generate input/output data for wasm calculation.
- */
-export interface WasmCalculationInteropDependencies<TTag> {
-    readonly imageIdHandler: IdHandler<RegisteredImage>;
-    readonly imageHandleBuffersController: ImageHandleBufferController;
-    readonly originReference: SpriteOriginReference;
-    readonly spriteIdHandler: IdHandler<InternalSpriteCurrentState<TTag>>;
-}
-/**
- * Create calculation host that wasm implementation.
- * @param TTag Tag type.
- * @param params Projection host params.
- * @param deps Wasm interoperability dependencies.
- * @returns Calculation host.
- */
-export declare const createWasmCalculationHost: <TTag>(params: ProjectionHostParams, deps: WasmCalculationInteropDependencies<TTag>) => RenderCalculationHost<TTag>;
-export declare const __wasmCalculationTestInternals: {
-    convertToWasmProjectionState: <TTag>(wasm: WasmHost, params: ProjectionHostParams, deps: WasmCalculationInteropDependencies<TTag>) => WritableWasmProjectionState<TTag>;
-    converToPreparedDrawImageParams: <TTag>(state: WritableWasmProjectionState<TTag>, deps: WasmCalculationInteropDependencies<TTag>, resultBuffer: BufferHolder<Float64Array>) => PreparedDrawSpriteImageParams<TTag>[];
-    prepareDrawSpriteImagesInternal: <TTag>(wasm: WasmHost, wasmState: WritableWasmProjectionState<TTag>, deps: WasmCalculationInteropDependencies<TTag>, params: PrepareDrawSpriteImageParams<TTag>) => PreparedDrawSpriteImageParams<TTag>[];
-    processInterpolationsViaWasm: (wasm: WasmHost, requests: ProcessInterpolationPresetRequests, timestamp: number) => WasmProcessInterpolationResults;
-    processInterpolationsWithWasm: <TTag>(wasm: WasmHost, params: RenderInterpolationParams<TTag>) => RenderInterpolationResult;
-};
-export {};

package/dist/host/wasmHost.d.ts

@@ -1,133 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.0
- * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { SpriteLayerCalculationVariant } from '../types';
-/**
- * `fromLngLat` function parameter
- */
-export type WasmFromLngLat = (lng: number, lat: number, altitude: number, outPtr: number) => boolean;
-/**
- * `project` function parameter
- */
-export type WasmProject = (lng: number, lat: number, altitude: number, worldSize: number, matrixPtr: number, outPtr: number) => boolean;
-/**
- * `unproject` function parameter
- */
-export type WasmUnproject = (x: number, y: number, worldSize: number, matrixPtr: number, outPtr: number) => boolean;
-/**
- * `calculatePerspectiveRatio` function parameter
- */
-export type WasmCalculatePerspectiveRatio = (lng: number, lat: number, altitude: number, cachedMercatorPtr: number, cameraToCenterDistance: number, matrixPtr: number, outPtr: number) => boolean;
-export type WasmProjectLngLatToClipSpace = (lng: number, lat: number, altitude: number, matrixPtr: number, outPtr: number) => boolean;
-export type WasmCalculateBillboardDepthKey = (centerX: number, centerY: number, worldSize: number, inverseMatrixPtr: number, mercatorMatrixPtr: number, outPtr: number) => boolean;
-export type WasmCalculateSurfaceDepthKey = (baseLng: number, baseLat: number, baseAltitude: number, displacementPtr: number, displacementCount: number, indexPtr: number, indexCount: number, mercatorMatrixPtr: number, applyBias: number, biasNdc: number, minClipZEpsilon: number, outPtr: number) => boolean;
-export type WasmPrepareDrawSpriteImages = (paramsPtr: number, resultPtr: number) => boolean;
-export type WasmProcessInterpolations = (paramsPtr: number, resultPtr: number) => boolean;
-/**
- * Wasm raw pointer type.
- */
-export type Pointer = number;
-/**
- * An array element type that createTypedBuffer.
- * @param TArray - A type for ArrayBufferView (ex: Float64Array)
- */
-export type TypedArrayElement<TArray> = TArray extends {
-    [index: number]: infer T;
-} ? T : never;
-/**
- * Typed ArrayBufferView.
- * @param TArray - A type for ArrayBufferView (ex: Float64Array)
- */
-export interface TypedArrayBufferView<TArray> extends ArrayBufferView {
-    /**
-     * Copy in an array.
-     * @param from An array.
-     */
-    readonly set: (from: ArrayLike<TypedArrayElement<TArray>>) => void;
-    readonly length: number;
-}
-/**
- * TypedArrayBuffer view constructor type.
- * @param TArray - A type for ArrayBufferView (ex: Float64Array)
- */
-export type TypedArrayConstructor<TArray extends TypedArrayBufferView<TArray>> = {
-    readonly BYTES_PER_ELEMENT: number;
-    new (buffer: ArrayBuffer, byteOffset: number, length: number): TArray;
-};
-/**
- * The BufferHolder, capsule both wasm raw memory pointer and ArrayBufferBuffer.
- * @param TArray - A type for ArrayBufferView (ex: Float64Array)
- */
-export interface BufferHolder<TArray extends TypedArrayBufferView<TArray>> {
-    /**
-     * Element count (Float64Array: mod 8)
-     */
-    readonly length: number;
-    /**
-     * Prepare and get the raw pointer and the buffer reference.
-     * @returns The raw pointer and the buffer reference.
-     */
-    readonly prepare: () => {
-        ptr: Pointer;
-        buffer: TArray;
-    };
-    /**
-     * Release the buffer.
-     * @returns
-     */
-    readonly release: () => void;
-}
-/**
- * Wasm host reference.
- */
-export interface WasmHost {
-    /**
-     * Helper for wasm interoperation buffer.
-     * @param TArray - A type for ArrayBufferView (ex: Float64Array)
-     * @param ArrayType - ArrayBufferView constructor
-     * @param elements - Buffer element count or copy in data array.
-     */
-    readonly allocateTypedBuffer: <TArray extends TypedArrayBufferView<TArray>>(ArrayType: TypedArrayConstructor<TArray>, elements: number | ArrayLike<TypedArrayElement<TArray>>) => BufferHolder<TArray>;
-    readonly fromLngLat: WasmFromLngLat;
-    readonly project: WasmProject;
-    readonly unproject: WasmUnproject;
-    readonly calculatePerspectiveRatio: WasmCalculatePerspectiveRatio;
-    readonly projectLngLatToClipSpace: WasmProjectLngLatToClipSpace;
-    readonly calculateBillboardDepthKey: WasmCalculateBillboardDepthKey;
-    readonly calculateSurfaceDepthKey: WasmCalculateSurfaceDepthKey;
-    readonly prepareDrawSpriteImages: WasmPrepareDrawSpriteImages;
-    readonly processInterpolations: WasmProcessInterpolations;
-}
-export type WasmVariant = SpriteLayerCalculationVariant;
-/**
- * Wasm initialization options.
- */
-export interface InitializeWasmHostOptions {
-    /** Force initialization. Default is false. */
-    readonly force: boolean;
-    /** Override the URL used to fetch wasm artifacts. */
-    readonly wasmBaseUrl: string | undefined;
-}
-/**
- * Initialize wasm offload module.
- * @param preferredVariant Uses wasm offload module variant.
- * @param options Options.
- * @returns Initialized WasmHost.
- */
-export declare const initializeWasmHost: (preferredVariant: WasmVariant, options: InitializeWasmHostOptions) => Promise<WasmVariant>;
-/**
- * Release wasm offload module.
- */
-export declare const releaseWasmHost: () => void;
-/**
- * Get wasm host.
- * @returns Entry points.
- */
-export declare const prepareWasmHost: () => WasmHost;

package/dist/host/wasmProjectionHost.d.ts

@@ -1,19 +0,0 @@
-/*!
- * name: maplibre-gl-layers
- * version: 0.19.0
- * description: MapLibre's layer extension library enabling the display, movement, and modification of large numbers of dynamic sprite images
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/maplibre-gl-layers.git
- * git.commit.hash: 7bc93c11d7855dedb8d60f140af4e413252c32a7
- */
-
-import { ProjectionHostParams } from './projectionHost';
-import { ProjectionHost } from '../internalTypes';
-/**
- * Create wasm-based calculation projection host.
- * @param params Projection parameters
- * @returns Projection host
- * @remarks This needs using before initialization (initializeWasmHost function)
- */
-export declare const createWasmProjectionHost: (params: ProjectionHostParams) => ProjectionHost;