maplibre-gl-layers 0.13.0 → 0.15.0

package/README.md

@@ -27,7 +27,7 @@ Here is a minimal example that places a single sprite:
 import { Map } from 'maplibre-gl';
 import {
   createSpriteLayer,
-  initializeSpriteLayerHost,
+  initializeRuntimeHost,
 } from 'maplibre-gl-layers';
 
 // Create the MapLibre instance
@@ -43,8 +43,8 @@ const spriteLayer = createSpriteLayer({ id: 'vehicles' });
 
 // When MapLibre is ready
 map.on('load', async () => {
-  // Optional: enable WASM acceleration (falls back to JS when unavailable)
-  await initializeSpriteLayerHost();
+  // Initialize and add SpriteLayer to MapLibre
+  await initializeRuntimeHost();
   map.addLayer(spriteLayer);
 
   // Register an image that can be referenced by sprites

package/dist/SpriteLayer.d.ts

@@ -1,21 +1,15 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
-import { SpriteLayerInterface, SpriteLayerOptions, SpriteAnchor, SpriteLocation, SpriteImageDefinitionInit, SpriteImageOffset, SpriteInterpolationOptions, SpriteLayerCalculationVariant } from './types';
+import { SpriteLayerInterface, SpriteLayerOptions, SpriteLocation, SpriteImageDefinitionInit } from './types';
 import { InternalSpriteImageState, InternalSpriteCurrentState, SpriteOriginReference } from './internalTypes';
-export interface SpriteLayerHostOptions {
-    readonly variant?: SpriteLayerCalculationVariant;
-    readonly wasmBaseUrl?: string;
-}
-export declare const initializeSpriteLayerHost: (variantOrOptions?: SpriteLayerCalculationVariant | SpriteLayerHostOptions) => Promise<SpriteLayerCalculationVariant>;
-export declare const releaseSpriteLayerHost: () => void;
 /**
  * Applies auto-rotation to all images within a sprite when movement exceeds the configured threshold.
  * @template T Arbitrary sprite tag type.
@@ -24,24 +18,6 @@ export declare const releaseSpriteLayerHost: () => void;
  * @returns {boolean} `true` when auto-rotation was applied, `false` otherwise.
  */
 export declare const applyAutoRotation: <T>(sprite: InternalSpriteCurrentState<T>, nextLocation: SpriteLocation) => boolean;
-/**
- * Clones a sprite anchor, defaulting to the origin when none supplied.
- * @param {SpriteAnchor} [anchor] - Anchor to clone.
- * @returns {SpriteAnchor} Safe copy for mutation within the layer state.
- */
-export declare const cloneAnchor: (anchor?: SpriteAnchor) => SpriteAnchor;
-/**
- * Clones an image offset, applying defaults when missing.
- * @param {SpriteImageOffset} [offset] - Offset definition to copy.
- * @returns {SpriteImageOffset} Cloned offset structure.
- */
-export declare const cloneOffset: (offset?: SpriteImageOffset) => SpriteImageOffset;
-/**
- * Deep-clones interpolation options to prevent shared references between sprites.
- * @param {SpriteInterpolationOptions} options - Options provided by the user.
- * @returns {SpriteInterpolationOptions} Cloned options object.
- */
-export declare const cloneInterpolationOptions: (options: SpriteInterpolationOptions) => SpriteInterpolationOptions;
 /**
  * Creates internal sprite image state from initialization data and layer bookkeeping fields.
  * @param {SpriteImageDefinitionInit} imageInit - Caller-provided image definition.

package/dist/config.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
 /** Debug flag */
@@ -16,3 +16,11 @@ export declare const USE_SHADER_BILLBOARD_GEOMETRY = true;
 export declare const USE_SHADER_SURFACE_GEOMETRY = true;
 /** Whether to enable the NDC bias for surface rendering (disabled by default). */
 export declare const ENABLE_NDC_BIAS_SURFACE = true;
+/** Maximum number of atlas operations handled per processing pass. */
+export declare const ATLAS_QUEUE_CHUNK_SIZE = 64;
+/** Time budget (milliseconds) spent per atlas queue processing pass. */
+export declare const ATLAS_QUEUE_TIME_BUDGET_MS = 20;
+/** Maximum number of text glyph jobs handled per processing pass. */
+export declare const TEXT_GLYPH_QUEUE_CHUNK_SIZE = 16;
+/** Time budget (milliseconds) spent on text glyph generation per pass. */
+export declare const TEXT_GLYPH_QUEUE_TIME_BUDGET_MS = 20;

package/dist/const.d.ts

@@ -1,14 +1,14 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
-import { Rect } from './looseQuadTree';
+import { Rect } from './utils/looseQuadTree';
 import { SpriteAnchor, SpriteImageOffset, SpriteTextGlyphHorizontalAlign } from './types';
 /** Default sprite anchor centered at the image origin. */
 export declare const DEFAULT_ANCHOR: Readonly<SpriteAnchor>;

package/dist/default.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
 import { SpriteScalingOptions, SpriteTextureFilteringOptions } from './types';

package/dist/gl/atlas.d.ts

@@ -0,0 +1,64 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.15.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: d850b7e9c713f54f0630248dc4ea370721b6965b
+ */
+
+import { Deferred } from 'async-primitives';
+import { Canvas2DSource } from '../internalTypes';
+export interface AtlasManagerOptions {
+    readonly pageWidth?: number;
+    readonly pageHeight?: number;
+    readonly padding?: number;
+}
+export interface AtlasPlacement {
+    readonly pageIndex: number;
+    readonly width: number;
+    readonly height: number;
+    readonly x: number;
+    readonly y: number;
+    readonly u0: number;
+    readonly v0: number;
+    readonly u1: number;
+    readonly v1: number;
+}
+export interface AtlasPageState {
+    readonly index: number;
+    readonly width: number;
+    readonly height: number;
+    readonly canvas: Canvas2DSource;
+    needsUpload: boolean;
+}
+export interface AtlasManager {
+    readonly upsertImage: (id: string, bitmap: ImageBitmap) => AtlasPlacement;
+    readonly removeImage: (id: string) => boolean;
+    readonly getImagePlacement: (id: string) => AtlasPlacement | null;
+    readonly getPages: () => readonly AtlasPageState[];
+    readonly markPageClean: (pageIndex: number) => void;
+    readonly clear: () => void;
+}
+export interface AtlasQueueUpsertEntry {
+    readonly imageId: string;
+    readonly bitmap: ImageBitmap;
+    readonly deferred: Deferred<boolean>;
+}
+export interface AtlasQueueOptions {
+    readonly maxOperationsPerPass: number;
+    readonly timeBudgetMs: number;
+}
+export interface AtlasQueueCallbacks {
+    readonly onChunkProcessed: () => void;
+}
+export interface AtlasOperationQueue {
+    readonly enqueueUpsert: (entry: AtlasQueueUpsertEntry) => void;
+    readonly flushPending: () => void;
+    readonly cancelForImage: (imageId: string, reason?: Error) => void;
+    readonly rejectAll: (reason: Error) => void;
+    readonly pendingCount: number;
+}
+export declare const createAtlasManager: (options?: AtlasManagerOptions) => AtlasManager;
+export declare const createAtlasOperationQueue: (atlasManager: AtlasManager, options: AtlasQueueOptions, callbacks: AtlasQueueCallbacks) => AtlasOperationQueue;

package/dist/gl/hitTest.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.15.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: d850b7e9c713f54f0630248dc4ea370721b6965b
+ */
+
+import { Map as MapLibreMap } from 'maplibre-gl';
+import { InternalSpriteCurrentState, InternalSpriteImageState, ProjectionHost, RegisteredImage } from '../internalTypes';
+import { SpriteScreenPoint } from '../types';
+import { ResolvedSpriteScalingOptions } from '../utils/math';
+export interface HitTestEntry<T> {
+    readonly sprite: InternalSpriteCurrentState<T>;
+    readonly image: InternalSpriteImageState;
+    readonly corners: readonly [
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint
+    ];
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minY: number;
+    readonly maxY: number;
+}
+export interface HitTestResult<T> {
+    readonly hitEntry: HitTestEntry<T> | null;
+    readonly screenPoint: SpriteScreenPoint;
+}
+export interface HitTestControllerParams {
+    readonly images: Map<string, RegisteredImage>;
+    readonly getResolvedScaling: () => ResolvedSpriteScalingOptions;
+}
+export interface HitTestController<T> {
+    readonly beginFrame: () => void;
+    readonly clearAll: () => void;
+    readonly getHitTestEntries: () => readonly HitTestEntry<T>[];
+    readonly registerHitTestEntry: (sprite: Readonly<InternalSpriteCurrentState<T>>, image: Readonly<InternalSpriteImageState>, corners: readonly [
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint
+    ], drawIndex: number) => void;
+    readonly removeImageBounds: (image: InternalSpriteImageState) => void;
+    readonly refreshSpriteHitTestBounds: (projectionHost: ProjectionHost, sprite: Readonly<InternalSpriteCurrentState<T>>) => void;
+    readonly findTopmostHitEntry: (point: SpriteScreenPoint, map: MapLibreMap | null) => HitTestEntry<T> | null;
+    readonly resolveHitTestResult: (nativeEvent: MouseEvent | PointerEvent | TouchEvent, canvasElement: HTMLCanvasElement | null, map: MapLibreMap | null) => HitTestResult<T> | null;
+    readonly setHitTestEnabled: (enabled: boolean) => boolean;
+    readonly isHitTestEnabled: () => boolean;
+}
+export declare const createHitTestController: <T>({ images, getResolvedScaling, }: HitTestControllerParams) => HitTestController<T>;

package/dist/{shader.d.ts → gl/shader.d.ts}

@@ -1,14 +1,15 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
-import { SpriteAnchor, SpriteScreenPoint } from './types';
+import { SpriteAnchor, SpriteScreenPoint } from '../types';
+import { PreparedDrawSpriteImageParams, Releasable } from '../internalTypes';
 /** Number of components per vertex (clipPosition.xyzw + uv.xy). */
 export declare const VERTEX_COMPONENT_COUNT = 6;
 /** Component count for clip-space position attributes. */
@@ -24,7 +25,7 @@ export declare const UV_OFFSET: number;
 /** Vertex count required to draw one sprite as two triangles. */
 export declare const QUAD_VERTEX_COUNT = 6;
 /** Shared vertex shader that converts screen-space vertices when requested. */
-export declare const VERTEX_SHADER_SOURCE: "\nattribute vec4 a_position;\nattribute vec2 a_uv;\nuniform vec2 u_screenToClipScale;\nuniform vec2 u_screenToClipOffset;\nuniform float u_billboardMode;\nuniform float u_surfaceMode;\nuniform vec2 u_billboardCenter;\nuniform vec2 u_billboardHalfSize;\nuniform vec2 u_billboardAnchor;\nuniform vec2 u_billboardSinCos;\nuniform float u_surfaceClipEnabled;\nuniform vec4 u_surfaceClipCenter;\nuniform vec4 u_surfaceClipBasisEast;\nuniform vec4 u_surfaceClipBasisNorth;\nuniform float u_surfaceDepthBias;\nvarying vec2 v_uv;\nvec2 computeBillboardCorner(vec2 uv) {\n  vec2 base = vec2(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);\n  vec2 anchorShift = vec2(u_billboardAnchor.x * u_billboardHalfSize.x, u_billboardAnchor.y * u_billboardHalfSize.y);\n  vec2 shifted = vec2(base.x * u_billboardHalfSize.x, base.y * u_billboardHalfSize.y) - anchorShift;\n  float sinR = u_billboardSinCos.x;\n  float cosR = u_billboardSinCos.y;\n  vec2 rotated = vec2(\n    shifted.x * cosR - shifted.y * sinR,\n    shifted.x * sinR + shifted.y * cosR\n  );\n  return vec2(\n    u_billboardCenter.x + rotated.x,\n    u_billboardCenter.y - rotated.y\n  );\n}\nvec4 computeSurfaceCorner(vec2 corner) {\n  if (u_surfaceClipEnabled < 0.5) {\n    return vec4(0.0, 0.0, 0.0, 1.0);\n  }\n  vec4 clip = u_surfaceClipCenter\n    + (corner.x * u_surfaceClipBasisEast)\n    + (corner.y * u_surfaceClipBasisNorth);\n  clip.z += u_surfaceDepthBias * clip.w;\n  return clip;\n}\nvoid main() {\n  v_uv = a_uv;\n  vec4 position;\n  if (u_billboardMode > 0.5) {\n    vec2 screenPosition = computeBillboardCorner(a_uv);\n    position = vec4(screenPosition, 0.0, 1.0);\n  } else if (u_surfaceMode > 0.5) {\n    vec2 baseCorner = vec2(a_position.x, a_position.y);\n    position = computeSurfaceCorner(baseCorner);\n  } else {\n    position = a_position;\n  }\n  position.xy = position.xy * u_screenToClipScale + u_screenToClipOffset;\n  gl_Position = position;\n}\n";
+export declare const VERTEX_SHADER_SOURCE: "\nattribute vec4 a_position;\nattribute vec2 a_uv;\nuniform vec2 u_screenToClipScale;\nuniform vec2 u_screenToClipOffset;\nuniform float u_billboardMode;\nuniform float u_surfaceMode;\nuniform vec2 u_billboardCenter;\nuniform vec2 u_billboardHalfSize;\nuniform vec2 u_billboardAnchor;\nuniform vec2 u_billboardSinCos;\nuniform float u_surfaceClipEnabled;\nuniform mat4 u_surfaceClipMatrix;\nuniform float u_surfaceDepthBias;\nvarying vec2 v_uv;\nvec2 computeBillboardCorner(vec2 baseCorner) {\n  vec2 anchorShift = vec2(u_billboardAnchor.x * u_billboardHalfSize.x, u_billboardAnchor.y * u_billboardHalfSize.y);\n  vec2 shifted = vec2(baseCorner.x * u_billboardHalfSize.x, baseCorner.y * u_billboardHalfSize.y) - anchorShift;\n  float sinR = u_billboardSinCos.x;\n  float cosR = u_billboardSinCos.y;\n  vec2 rotated = vec2(\n    shifted.x * cosR - shifted.y * sinR,\n    shifted.x * sinR + shifted.y * cosR\n  );\n  return vec2(\n    u_billboardCenter.x + rotated.x,\n    u_billboardCenter.y - rotated.y\n  );\n}\nvec4 computeSurfaceCorner(vec2 corner) {\n  if (u_surfaceClipEnabled < 0.5) {\n    return vec4(0.0, 0.0, 0.0, 1.0);\n  }\n  vec4 clip = u_surfaceClipMatrix * vec4(1.0, corner.x, corner.y, 0.0);\n  clip.z += u_surfaceDepthBias * clip.w;\n  return clip;\n}\nvoid main() {\n  v_uv = a_uv;\n  vec4 position;\n  if (u_billboardMode > 0.5) {\n    vec2 screenPosition = computeBillboardCorner(a_position.xy);\n    position = vec4(screenPosition, 0.0, 1.0);\n  } else if (u_surfaceMode > 0.5) {\n    vec2 baseCorner = vec2(a_position.x, a_position.y);\n    position = computeSurfaceCorner(baseCorner);\n  } else {\n    position = a_position;\n  }\n  position.xy = position.xy * u_screenToClipScale + u_screenToClipOffset;\n  gl_Position = position;\n}\n";
 /** Fragment shader that applies texture sampling and opacity. */
 export declare const FRAGMENT_SHADER_SOURCE: "\nprecision mediump float;\nuniform sampler2D u_texture;\nuniform float u_opacity;\nvarying vec2 v_uv;\nvoid main() {\n  vec4 texel = texture2D(u_texture, v_uv);\n  gl_FragColor = vec4(texel.rgb, texel.a) * u_opacity;\n}\n";
 /** Initial vertex data for a unit quad. */
@@ -81,3 +82,20 @@ export declare const compileShader: (glContext: WebGLRenderingContext, type: num
  * @throws When linking fails or a program cannot be created.
  */
 export declare const createShaderProgram: (glContext: WebGLRenderingContext, vertexSource: string, fragmentSource: string) => WebGLProgram;
+export interface SpriteDrawProgram<TTag> extends Releasable {
+    beginFrame(): void;
+    uploadVertexBatch(items: PreparedDrawSpriteImageParams<TTag>[]): void;
+    draw(prepared: PreparedDrawSpriteImageParams<TTag>): boolean;
+}
+export declare const createSpriteDrawProgram: <TTag>(glContext: WebGLRenderingContext) => SpriteDrawProgram<TTag>;
+export interface DebugOutlineRenderer extends Releasable {
+    begin(screenToClipScaleX: number, screenToClipScaleY: number, screenToClipOffsetX: number, screenToClipOffsetY: number): void;
+    drawOutline(corners: readonly [
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint
+    ]): void;
+    end(): void;
+}
+export declare const createDebugOutlineRenderer: (glContext: WebGLRenderingContext) => DebugOutlineRenderer;

package/dist/gl/text.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.15.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: d850b7e9c713f54f0630248dc4ea370721b6965b
+ */
+
+import { SpriteTextGlyphDimensions, SpriteTextGlyphOptions } from '../types';
+export interface TextGlyphRenderResult {
+    readonly bitmap: ImageBitmap;
+    readonly width: number;
+    readonly height: number;
+}
+export declare const renderTextGlyphBitmap: (text: string, dimensions: SpriteTextGlyphDimensions, options?: SpriteTextGlyphOptions) => Promise<TextGlyphRenderResult>;

package/dist/{calculationHost.d.ts → host/calculationHost.d.ts}

@@ -1,16 +1,16 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
 import { Map as MapLibreMap } from 'maplibre-gl';
-import { InternalSpriteCurrentState, InternalSpriteImageState, RegisteredImage, ProjectionHost, PreparedDrawSpriteImageParams, RenderCalculationHost, PrepareDrawSpriteImageParamsBefore, PrepareDrawSpriteImageParamsAfter } from './internalTypes';
-import { SpritePoint } from './types';
+import { DistanceInterpolationEvaluationParams, DistanceInterpolationEvaluationResult, DegreeInterpolationEvaluationParams, DegreeInterpolationEvaluationResult, InternalSpriteCurrentState, InternalSpriteImageState, RegisteredImage, ProjectionHost, PreparedDrawSpriteImageParams, RenderCalculationHost, PrepareDrawSpriteImageParamsBefore, PrepareDrawSpriteImageParamsAfter, RenderInterpolationParams, RenderInterpolationResult, SpriteInterpolationEvaluationParams, SpriteInterpolationEvaluationResult } from '../internalTypes';
+import { SpritePoint } from '../types';
 import { ProjectionHostParams } from './projectionHost';
 /**
  * Cache entry storing anchor-adjusted and raw centers for a sprite image.
@@ -31,6 +31,7 @@ type ImageCenterCache = Map<string, Map<string, ImageCenterCacheEntry>>;
  * culled or stored in another bucket).
  */
 type OriginImageResolver<T> = (sprite: Readonly<InternalSpriteCurrentState<T>>, image: Readonly<InternalSpriteImageState>) => InternalSpriteImageState | null;
+export declare const DEFAULT_RENDER_INTERPOLATION_RESULT: RenderInterpolationResult;
 interface DepthSortedItem<T> {
     readonly sprite: InternalSpriteCurrentState<T>;
     readonly image: InternalSpriteImageState;
@@ -43,6 +44,22 @@ export declare const collectDepthSortedItemsInternal: <T>(projectionHost: Projec
  * 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, zoomScaleFactor: number, originCenterCache: ImageCenterCache, { imageResources, baseMetersPerPixel, spriteMinPixel, spriteMaxPixel, 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 DistanceInterpolationEvaluationParams[];
+    readonly degree: readonly DegreeInterpolationEvaluationParams[];
+    readonly sprite: readonly SpriteInterpolationEvaluationParams[];
+}
+export interface ProcessInterpolationsEvaluationHandlers {
+    readonly prepare?: (requests: ProcessInterpolationPresetRequests) => void;
+    readonly evaluateDistance: (requests: readonly DistanceInterpolationEvaluationParams[]) => readonly DistanceInterpolationEvaluationResult[];
+    readonly evaluateDegree: (requests: readonly DegreeInterpolationEvaluationParams[]) => readonly DegreeInterpolationEvaluationResult[];
+    readonly evaluateSprite: (requests: readonly SpriteInterpolationEvaluationParams[]) => readonly SpriteInterpolationEvaluationResult[];
+}
+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.
@@ -60,4 +77,9 @@ export declare const createCalculationHost: <TTag>(params: ProjectionHostParams)
 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/{mapLibreProjectionHost.d.ts → host/mapLibreProjectionHost.d.ts}

@@ -1,15 +1,15 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
 import { Map as MapLibreMap } from 'maplibre-gl';
-import { ProjectionHost } from './internalTypes';
+import { ProjectionHost } from '../internalTypes';
 /**
  * Create a projection host that delegates to MapLibre.
  * @param map MapLibre map instance

package/dist/{projectionHost.d.ts → host/projectionHost.d.ts}

@@ -1,17 +1,17 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
 import { mat4 as Mat4 } from 'gl-matrix';
 import { Map as MapLibreMap } from 'maplibre-gl';
-import { SpriteLocation } from './types';
-import { ClipContext, ProjectionHost } from './internalTypes';
+import { SpriteLocation } from '../types';
+import { ClipContext, ProjectionHost } from '../internalTypes';
 /**
  * Required projection parameters. These correspond to the MapLibre transform state.
  */
@@ -43,6 +43,7 @@ export interface PreparedProjectionState {
     readonly pixelPerMeter: number;
     readonly cameraToCenterDistance: number;
     readonly clipContext: ClipContext | null;
+    readonly cameraLocation: SpriteLocation | null;
 }
 export declare const prepareProjectionState: (params: ProjectionHostParams) => PreparedProjectionState;
 /**

package/dist/host/runtime.d.ts

@@ -0,0 +1,38 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.15.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: d850b7e9c713f54f0630248dc4ea370721b6965b
+ */
+
+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/{wasmCalculationHost.d.ts → host/wasmCalculationHost.d.ts}

@@ -1,26 +1,24 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
-import { ClipContext, ImageHandleBufferController, IdHandler, InternalSpriteCurrentState, InternalSpriteImageState, PreparedDrawSpriteImageParams, PrepareDrawSpriteImageParams, Releaseable, RegisteredImage, RenderCalculationHost, SpriteOriginReference } from './internalTypes';
-import { SurfaceCorner } from './math';
-import { SpriteLocation, SpriteScreenPoint } from './types';
+import { DistanceInterpolationEvaluationResult, DegreeInterpolationEvaluationResult, 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';
-export declare const createWasmProjectLngLatToClipSpace: () => {
-    (clipContext: Readonly<ClipContext> | null, location: Readonly<SpriteLocation>): number[] | null;
-    release(): void;
-};
-export declare const createWasmCalculateBillboardDepthKey: (preparedState: PreparedProjectionState) => {
-    (_center: Readonly<SpriteScreenPoint>): number | null;
-    release(): void;
-};
+interface WasmProcessInterpolationResults {
+    readonly distance: DistanceInterpolationEvaluationResult[];
+    readonly degree: DegreeInterpolationEvaluationResult[];
+    readonly sprite: SpriteInterpolationEvaluationResult[];
+}
 type CalculateSurfaceDepthKeyOptions = {
     readonly indices?: readonly number[];
     readonly bias?: {
@@ -32,7 +30,7 @@ export declare const createWasmCalculateSurfaceDepthKey: (preparedState: Prepare
     (baseLngLat: Readonly<SpriteLocation>, displacements: readonly SurfaceCorner[], options?: CalculateSurfaceDepthKeyOptions): number | null;
     release(): void;
 };
-interface PreparedInputBuffer extends Releaseable {
+interface PreparedInputBuffer extends Releasable {
     readonly parameterHolder: BufferHolder<Float64Array>;
     readonly resultItemCount: number;
 }
@@ -64,5 +62,7 @@ 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) => WasmProcessInterpolationResults;
+    processInterpolationsWithWasm: <TTag>(wasm: WasmHost, params: RenderInterpolationParams<TTag>) => RenderInterpolationResult;
 };
 export {};

package/dist/{wasmHost.d.ts → host/wasmHost.d.ts}

@@ -1,14 +1,14 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
-import { SpriteLayerCalculationVariant } from './types';
+import { SpriteLayerCalculationVariant } from '../types';
 /**
  * `fromLngLat` function parameter
  */
@@ -29,6 +29,7 @@ export type WasmProjectLngLatToClipSpace = (lng: number, lat: number, altitude:
 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.
  */
@@ -65,6 +66,10 @@ export type TypedArrayConstructor<TArray extends TypedArrayBufferView<TArray>> =
  * @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.
@@ -92,12 +97,13 @@ export interface WasmHost {
     readonly allocateTypedBuffer: <TArray extends TypedArrayBufferView<TArray>>(ArrayType: TypedArrayConstructor<TArray>, elements: number | ArrayLike<TypedArrayElement<TArray>>) => BufferHolder<TArray>;
     readonly fromLngLat: WasmFromLngLat;
     readonly project: WasmProject;
-    readonly calculatePerspectiveRatio: WasmCalculatePerspectiveRatio;
     readonly unproject: WasmUnproject;
+    readonly calculatePerspectiveRatio: WasmCalculatePerspectiveRatio;
     readonly projectLngLatToClipSpace: WasmProjectLngLatToClipSpace;
     readonly calculateBillboardDepthKey: WasmCalculateBillboardDepthKey;
     readonly calculateSurfaceDepthKey: WasmCalculateSurfaceDepthKey;
-    readonly prepareDrawSpriteImages?: WasmPrepareDrawSpriteImages;
+    readonly prepareDrawSpriteImages: WasmPrepareDrawSpriteImages;
+    readonly processInterpolations: WasmProcessInterpolations;
 }
 export type WasmVariant = SpriteLayerCalculationVariant;
 /**
@@ -105,9 +111,9 @@ export type WasmVariant = SpriteLayerCalculationVariant;
  */
 export interface InitializeWasmHostOptions {
     /** Force initialization. Default is false. */
-    readonly force?: boolean;
+    readonly force: boolean;
     /** Override the URL used to fetch wasm artifacts. */
-    readonly wasmBaseUrl?: string;
+    readonly wasmBaseUrl: string | undefined;
 }
 /**
  * Initialize wasm offload module.
@@ -115,7 +121,7 @@ export interface InitializeWasmHostOptions {
  * @param options Options.
  * @returns Initialized WasmHost.
  */
-export declare const initializeWasmHost: (preferredVariant: WasmVariant, options?: InitializeWasmHostOptions) => Promise<WasmVariant>;
+export declare const initializeWasmHost: (preferredVariant?: WasmVariant, options?: InitializeWasmHostOptions) => Promise<WasmVariant>;
 /**
  * Release wasm offload module.
  */

package/dist/{wasmProjectionHost.d.ts → host/wasmProjectionHost.d.ts}

@@ -1,15 +1,15 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.13.0
+ * version: 0.15.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: 4934aa7f4fed93594ece419184b32b5b972bbb88
+ * git.commit.hash: d850b7e9c713f54f0630248dc4ea370721b6965b
  */
 
 import { ProjectionHostParams } from './projectionHost';
-import { ProjectionHost } from './internalTypes';
+import { ProjectionHost } from '../internalTypes';
 /**
  * Create wasm-based calculation projection host.
  * @param params Projection parameters