maplibre-gl-layers 0.14.0 → 0.16.0

package/dist/SpriteLayer.d.ts

@@ -1,14 +1,14 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
-import { SpriteLayerInterface, SpriteLayerOptions, SpriteAnchor, SpriteLocation, SpriteImageDefinitionInit, SpriteImageOffset, SpriteInterpolationOptions } from './types';
+import { SpriteLayerInterface, SpriteLayerOptions, SpriteLocation, SpriteImageDefinitionInit } from './types';
 import { InternalSpriteImageState, InternalSpriteCurrentState, SpriteOriginReference } from './internalTypes';
 /**
  * Applies auto-rotation to all images within a sprite when movement exceeds the configured threshold.
@@ -18,33 +18,16 @@ import { InternalSpriteImageState, InternalSpriteCurrentState, SpriteOriginRefer
  * @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.
  * @param {number} subLayer - Sub-layer index the image belongs to.
  * @param {number} order - Ordering slot within the sub-layer.
  * @param {SpriteOriginReference} originReference - Encode/Decode origin reference.
+ * @param {boolean} invalidated - Initially invalidate state.
  * @returns {InternalSpriteImageState} Normalized internal state ready for rendering.
  */
-export declare const createImageStateFromInit: (imageInit: SpriteImageDefinitionInit, subLayer: number, order: number, originReference: SpriteOriginReference) => InternalSpriteImageState;
+export declare const createImageStateFromInit: (imageInit: SpriteImageDefinitionInit, subLayer: number, order: number, originReference: SpriteOriginReference, invalidated: boolean) => InternalSpriteImageState;
 /**
  * Factory that creates the MapLibre layer interface for the sprite layer.
  * Implements the CustomLayerInterface lifecycle (init -> render -> dispose), packing thousands

package/dist/config.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
 /** Debug flag */

package/dist/const.d.ts

@@ -1,14 +1,14 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
-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>;
@@ -21,6 +21,10 @@ export declare const DEFAULT_TEXT_GLYPH_COLOR = "#000000";
 export declare const DEFAULT_TEXT_GLYPH_ALIGN: SpriteTextGlyphHorizontalAlign;
 export declare const DEFAULT_TEXT_GLYPH_FONT_SIZE = 32;
 export declare const DEFAULT_TEXT_GLYPH_RENDER_PIXEL_RATIO = 1;
+/** Default threshold in meters for auto-rotation to treat movement as significant. */
+export declare const DEFAULT_AUTO_ROTATION_MIN_DISTANCE_METERS = 20;
+/** Default border width in meters for sprite image outlines. */
+export declare const DEFAULT_BORDER_WIDTH_METERS = 1;
 /**
  * WGS84-compatible Earth radius in meters.
  * Used to convert one radian of longitude into meters when scaling sprites.

package/dist/default.d.ts

@@ -1,11 +1,11 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
 import { SpriteScalingOptions, SpriteTextureFilteringOptions } from './types';

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

@@ -1,15 +1,15 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
-import { Canvas2DSource } from './internalTypes';
 import { Deferred } from 'async-primitives';
+import { Canvas2DSource } from '../internalTypes';
 export interface AtlasManagerOptions {
     readonly pageWidth?: number;
     readonly pageHeight?: number;

package/dist/gl/hitTest.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.16.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ */
+
+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> | undefined;
+    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 | undefined) => HitTestEntry<T> | undefined;
+    readonly resolveHitTestResult: (nativeEvent: MouseEvent | PointerEvent | TouchEvent, canvasElement: HTMLCanvasElement | undefined, map: MapLibreMap | undefined) => HitTestResult<T> | undefined;
+    readonly setHitTestEnabled: (enabled: boolean) => boolean;
+    readonly isHitTestEnabled: () => boolean;
+}
+export declare const createHitTestController: <T>({ images, getResolvedScaling, }: HitTestControllerParams) => HitTestController<T>;

package/dist/gl/shader.d.ts

@@ -0,0 +1,115 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.16.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ */
+
+import { SpriteAnchor, SpriteScreenPoint, SpriteTextureFilteringOptions } from '../types';
+import { ImageHandleBufferController, PreparedDrawSpriteImageParams, RegisteredImage, Releasable, ResolvedTextureFilteringOptions } from '../internalTypes';
+import { AtlasManager, AtlasOperationQueue, AtlasPageState } from './atlas';
+import { RgbaColor } from '../utils/color';
+/** Number of components per vertex (clipPosition.xyzw + uv.xy). */
+export declare const VERTEX_COMPONENT_COUNT = 6;
+/** Component count for clip-space position attributes. */
+export declare const POSITION_COMPONENT_COUNT = 4;
+/** Component count for UV attributes. */
+export declare const UV_COMPONENT_COUNT = 2;
+/** Byte size of a Float32. */
+export declare const FLOAT_SIZE: number;
+/** Stride per vertex in bytes. */
+export declare const VERTEX_STRIDE: number;
+/** Byte offset for the UV attribute. */
+export declare const UV_OFFSET: number;
+/** Vertex count required to draw one sprite as two triangles. */
+export declare const QUAD_VERTEX_COUNT = 6;
+/** Initial vertex data for a unit quad. */
+export declare const INITIAL_QUAD_VERTICES: Float32Array<ArrayBuffer>;
+/** Scratch buffer rewritten for each draw call. */
+export declare const QUAD_VERTEX_SCRATCH: Float32Array<ArrayBuffer>;
+/** Corner traversal order used when outlining a quad without crossing diagonals. */
+export declare const BORDER_OUTLINE_CORNER_ORDER: readonly [0, 1, 3, 2];
+/** Base corner definitions used when expanding billboards in shaders. */
+export declare const BILLBOARD_BASE_CORNERS: ReadonlyArray<readonly [number, number]>;
+/** Base corner definitions used when expanding surface quads in shaders. */
+export declare const SURFACE_BASE_CORNERS: ReadonlyArray<readonly [number, number]>;
+export declare const computeBillboardCornersShaderModel: ({ center, halfWidth, halfHeight, anchor, rotationDeg, }: {
+    center: Readonly<SpriteScreenPoint>;
+    halfWidth: number;
+    halfHeight: number;
+    anchor?: Readonly<SpriteAnchor>;
+    rotationDeg: number;
+}) => Array<{
+    x: number;
+    y: number;
+    u: number;
+    v: number;
+}>;
+/**
+ * Compiles a shader from source, throwing if compilation fails.
+ * @param {WebGLRenderingContext} glContext - Active WebGL context.
+ * @param {number} type - Shader type (`VERTEX_SHADER` or `FRAGMENT_SHADER`).
+ * @param {string} source - GLSL source code.
+ * @returns {WebGLShader} Compiled shader object.
+ * @throws When shader creation or compilation fails.
+ */
+export declare const compileShader: (glContext: WebGLRenderingContext, type: number, source: string) => WebGLShader;
+/**
+ * Links a vertex and fragment shader into a WebGL program.
+ * @param {WebGLRenderingContext} glContext - Active WebGL context.
+ * @param {string} vertexSource - Vertex shader GLSL source.
+ * @param {string} fragmentSource - Fragment shader GLSL source.
+ * @returns {WebGLProgram} Linked shader program ready for use.
+ * @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 BorderOutlineRenderer extends Releasable {
+    begin(screenToClipScaleX: number, screenToClipScaleY: number, screenToClipOffsetX: number, screenToClipOffsetY: number): void;
+    drawOutline(corners: readonly [
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint,
+        SpriteScreenPoint
+    ], color: RgbaColor, lineWidth: number): void;
+    end(): void;
+}
+export declare const createBorderOutlineRenderer: (glContext: WebGLRenderingContext) => BorderOutlineRenderer;
+export interface LeaderLineRenderer extends Releasable {
+    begin(screenToClipScaleX: number, screenToClipScaleY: number, screenToClipOffsetX: number, screenToClipOffsetY: number): void;
+    drawLine(from: Readonly<SpriteScreenPoint>, to: Readonly<SpriteScreenPoint>, color: RgbaColor, lineWidth: number): void;
+    end(): void;
+}
+export declare const createLeaderLineRenderer: (glContext: WebGLRenderingContext) => LeaderLineRenderer;
+export declare const resolveTextureFilteringOptions: (options?: SpriteTextureFilteringOptions) => ResolvedTextureFilteringOptions;
+export declare const resolveAnisotropyExtension: (glContext: WebGLRenderingContext) => EXT_texture_filter_anisotropic | undefined;
+export interface EnsureTexturesParams {
+    readonly glContext: WebGLRenderingContext | undefined;
+    readonly atlasQueue: AtlasOperationQueue;
+    readonly atlasManager: AtlasManager;
+    readonly atlasPageTextures: Map<number, WebGLTexture>;
+    readonly atlasNeedsUpload: boolean;
+    readonly resolvedTextureFiltering: ResolvedTextureFilteringOptions;
+    readonly anisotropyExtension: EXT_texture_filter_anisotropic | undefined;
+    readonly maxSupportedAnisotropy: number;
+    readonly images: ReadonlyMap<string, RegisteredImage>;
+    readonly imageHandleBuffersController: ImageHandleBufferController;
+    readonly atlasPageIndexNone: number;
+    readonly shouldUploadAtlasPages: (pageStates?: readonly AtlasPageState[]) => boolean;
+}
+/**
+ * Creates or refreshes WebGL textures for registered images.
+ * Processes only queued entries to avoid unnecessary work.
+ * Intended to run just before drawing; returns immediately if the GL context is unavailable.
+ * Ensures registerImage calls outside the render loop sync on the next frame.
+ * @returns {boolean} Updated atlas upload requirement flag.
+ */
+export declare const ensureTextures: ({ glContext, atlasQueue, atlasManager, atlasPageTextures, atlasNeedsUpload, resolvedTextureFiltering, anisotropyExtension, maxSupportedAnisotropy, images, imageHandleBuffersController, atlasPageIndexNone, shouldUploadAtlasPages, }: EnsureTexturesParams) => boolean;

package/dist/gl/text.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * name: maplibre-gl-layers
+ * version: 0.16.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: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
+ */
+
+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.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
 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.
@@ -30,7 +30,8 @@ type ImageCenterCache = Map<string, Map<string, ImageCenterCacheEntry>>;
  * 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 | null;
+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;
@@ -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.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
 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.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
 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.
  */
@@ -20,6 +20,7 @@ export interface ProjectionHostParams {
     readonly width: number;
     readonly height: number;
     readonly center: Readonly<SpriteLocation>;
+    readonly cameraLocation: SpriteLocation | undefined;
     readonly pitchDeg?: number;
     readonly bearingDeg?: number;
     readonly rollDeg?: number;
@@ -36,13 +37,14 @@ export interface ProjectionHostParams {
 }
 export interface PreparedProjectionState {
     readonly zoom: number;
-    readonly mercatorMatrix: Mat4 | null;
-    readonly pixelMatrix: Mat4 | null;
-    readonly pixelMatrixInverse: Mat4 | null;
+    readonly mercatorMatrix: Mat4 | undefined;
+    readonly pixelMatrix: Mat4 | undefined;
+    readonly pixelMatrixInverse: Mat4 | undefined;
     readonly worldSize: number;
     readonly pixelPerMeter: number;
     readonly cameraToCenterDistance: number;
-    readonly clipContext: ClipContext | null;
+    readonly clipContext: ClipContext | undefined;
+    readonly cameraLocation: SpriteLocation | undefined;
 }
 export declare const prepareProjectionState: (params: ProjectionHostParams) => PreparedProjectionState;
 /**

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

@@ -1,15 +1,16 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
-import { SpriteLayerCalculationVariant, SpriteLayerHostOptions } from './types';
+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.

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

@@ -1,26 +1,24 @@
 /*!
  * name: maplibre-gl-layers
- * version: 0.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
-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,12 +30,16 @@ 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;
 }
 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)[];
@@ -64,5 +66,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.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
-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.
  */
@@ -101,7 +102,8 @@ export interface WasmHost {
     readonly projectLngLatToClipSpace: WasmProjectLngLatToClipSpace;
     readonly calculateBillboardDepthKey: WasmCalculateBillboardDepthKey;
     readonly calculateSurfaceDepthKey: WasmCalculateSurfaceDepthKey;
-    readonly prepareDrawSpriteImages?: WasmPrepareDrawSpriteImages;
+    readonly prepareDrawSpriteImages: WasmPrepareDrawSpriteImages;
+    readonly processInterpolations: WasmProcessInterpolations;
 }
 export type WasmVariant = SpriteLayerCalculationVariant;
 /**
@@ -119,7 +121,7 @@ export interface InitializeWasmHostOptions {
  * @param options Options.
  * @returns Initialized WasmHost.
  */
-export declare const initializeWasmHost: (preferredVariant: WasmVariant, options: InitializeWasmHostOptions | undefined) => 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.14.0
+ * version: 0.16.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: a531802b05777e1f54a8828a247254293df1415d
+ * git.commit.hash: 8d2149a6811cac25ed9d8c1d97acde73e1a38e25
  */
 
 import { ProjectionHostParams } from './projectionHost';
-import { ProjectionHost } from './internalTypes';
+import { ProjectionHost } from '../internalTypes';
 /**
  * Create wasm-based calculation projection host.
  * @param params Projection parameters