@navaramap/worker 0.0.0

package/src/tasks/upsampleQuantizedMeshTerrainMesh.ts

@@ -0,0 +1,38 @@
+import {
+  ReturnedConstructedTerrainMeshLike,
+  TransferableTileLike,
+  UpsamplableTerrainGeometryLike,
+} from "@navaramap/core";
+import { upsampleQuantizedMeshTerrainMesh as upsampleQuantizedMeshTerrainMeshImpl } from "@navaramap/engine-worker";
+
+import { transfer } from "..";
+import { transferReturnedConstructedTerrainMesh } from "../helpers/transferReturnedConstructedTerrainMesh";
+import { toTransferableTile, toUpsamplableTerrainGeometry } from "../utils";
+
+import { waitWasm } from "./waitWasm";
+
+export async function upsampleQuantizedMeshTerrainMesh(
+  tile: TransferableTileLike,
+  parentTile: TransferableTileLike,
+  upsamplableGeometry: UpsamplableTerrainGeometryLike,
+  skirt: boolean,
+  skirtExaggeration: number,
+  geographic: boolean,
+  tms: boolean,
+): Promise<ReturnedConstructedTerrainMeshLike> {
+  await waitWasm();
+
+  const mesh = upsampleQuantizedMeshTerrainMeshImpl(
+    toTransferableTile(tile),
+    toTransferableTile(parentTile),
+    toUpsamplableTerrainGeometry(upsamplableGeometry),
+    skirt,
+    skirtExaggeration,
+    geographic,
+    tms,
+  );
+  const { result, transfers } = transferReturnedConstructedTerrainMesh(mesh);
+  mesh.free();
+
+  return transfer(result, transfers);
+}

package/src/tasks/upsampleTerrainMesh.ts

@@ -0,0 +1,40 @@
+import {
+  ReturnedConstructedTerrainMeshLike,
+  TransferableRasterDEMDataLike,
+  TransferableTileLike,
+  UpsamplableTerrainGeometryLike,
+} from "@navaramap/core";
+import { upsampleTerrainMesh as upsampleTerrainMeshImpl } from "@navaramap/engine-worker";
+
+import { transfer } from "..";
+import { transferReturnedConstructedTerrainMesh } from "../helpers/transferReturnedConstructedTerrainMesh";
+import { toTransferableTile, toUpsamplableTerrainGeometry } from "../utils";
+import { toTransferableRasterDEMDataLike } from "../utils/toTransferableRasterDEMDataLike";
+
+import { waitWasm } from "./waitWasm";
+
+export async function upsampleTerrainMesh(
+  tile: TransferableTileLike,
+  parentTile: TransferableTileLike,
+  rasterDEMData: TransferableRasterDEMDataLike,
+  upsamplableGeometry: UpsamplableTerrainGeometryLike,
+  skirt: boolean,
+  skirtExaggeration: number,
+  tms: boolean,
+): Promise<ReturnedConstructedTerrainMeshLike> {
+  await waitWasm();
+
+  const mesh = upsampleTerrainMeshImpl(
+    toTransferableTile(tile),
+    toTransferableTile(parentTile),
+    toTransferableRasterDEMDataLike(rasterDEMData),
+    toUpsamplableTerrainGeometry(upsamplableGeometry),
+    skirt,
+    skirtExaggeration,
+    tms,
+  );
+  const { result, transfers } = transferReturnedConstructedTerrainMesh(mesh);
+  mesh.free();
+
+  return transfer(result, transfers);
+}

package/src/tasks/waitWasm.ts

@@ -0,0 +1,19 @@
+import init, { type InitOutput } from "@navaramap/engine-worker";
+
+let WASM: Promise<InitOutput> | undefined;
+
+export async function waitWasm(): Promise<InitOutput> {
+  WASM ??= init();
+  return WASM;
+}
+
+/**
+ * Reports this worker's WASM linear memory size in bytes (0 when WASM is not
+ * initialized yet). Linear memory only grows, so the main thread probes this
+ * after settled tasks to decide when to recycle the worker.
+ */
+export async function getWasmMemoryUsage(): Promise<number> {
+  if (!WASM) return 0;
+  const { memory } = await WASM;
+  return memory.buffer.byteLength;
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from "./toTransferableTileLike";
+export * from "./toTransferableMartiniLike";
+export * from "./toUpsamplableTerrainGeometryLike";
+export * from "./toExtentRadianF32Like";
+export * from "./toVec3Like";

package/src/utils/toExtentRadianF32Like.ts

@@ -0,0 +1,6 @@
+import type { ExtentRadianF32Like } from "@navaramap/core";
+import { ExtentRadianF32 } from "@navaramap/engine-worker";
+
+export function toExtentRadianF32Like(like: ExtentRadianF32Like) {
+  return new ExtentRadianF32(like.west, like.south, like.east, like.north);
+}

package/src/utils/toPolygonMaterialLike.ts

@@ -0,0 +1,20 @@
+import { type PolygonMaterialLike } from "@navaramap/core";
+import { PolygonMaterial } from "@navaramap/engine-worker";
+
+export function toPolygonMaterialLike(like: PolygonMaterialLike) {
+  const mat = new PolygonMaterial(
+    like.show,
+    like.castShadow,
+    like.receiveShadow,
+    like.color,
+    like.clampToGround,
+    like.tiled,
+    like.height,
+    like.extrudedHeight,
+    like.wireframe,
+    like.outline,
+    like.perPositionHeight,
+    like.__internal__,
+  );
+  return mat;
+}

package/src/utils/toPolylineMaterialLike.ts

@@ -0,0 +1,17 @@
+import { PolylineMaterialLike } from "@navaramap/core";
+import { PolylineMaterial } from "@navaramap/engine-worker";
+
+export function toPolylineMaterialLike(like: PolylineMaterialLike) {
+  return new PolylineMaterial(
+    like.show,
+    like.castShadow,
+    like.receiveShadow,
+    like.color,
+    like.clampToGround,
+    like.tiled,
+    like.height,
+    like.width,
+    like.maxWidth,
+    like.__internal__,
+  );
+}

package/src/utils/toTransferableMartiniLike.ts

@@ -0,0 +1,6 @@
+import type { TransferableMartiniLike } from "@navaramap/core";
+import { TransferableMartini } from "@navaramap/engine-worker";
+
+export function toTransferableMartini(like: TransferableMartiniLike) {
+  return new TransferableMartini(like.size, like.coords);
+}

package/src/utils/toTransferablePolygonBatchedFeatureLike.ts

@@ -0,0 +1,41 @@
+import type { TransferablePolygonBatchedFeatureLike } from "@navaramap/core";
+import { TransferablePolygonBatchedFeature } from "@navaramap/engine-worker";
+
+export function toTransferablePolygonBatchedFeatureLike(
+  like: TransferablePolygonBatchedFeatureLike,
+) {
+  const t = new TransferablePolygonBatchedFeature(like.crs, like.length);
+
+  t.setOuterRing(like.outer_ring.length, (b: Float64Array) => {
+    b.set(like.outer_ring);
+  });
+  t.setOuterRingSizes(like.outer_ring_sizes.length, (b: Uint32Array) => {
+    b.set(like.outer_ring_sizes);
+  });
+  t.setHoles(like.holes.length, (b: Float64Array) => {
+    b.set(like.holes);
+  });
+  t.setHolesSizes(like.holes_sizes.length, (b: Uint32Array) => {
+    b.set(like.holes_sizes);
+  });
+  t.setHolesTotalSizes(like.holes_total_sizes.length, (b: Uint32Array) => {
+    b.set(like.holes_total_sizes);
+  });
+  t.setHolesBoundaries(like.holes_boundaries.length, (b: Uint32Array) => {
+    b.set(like.holes_boundaries);
+  });
+  t.setExpectedWindingOrders(
+    like.expected_winding_orders.length,
+    (b: Uint32Array) => {
+      b.set(like.expected_winding_orders);
+    },
+  );
+  t.setBatchIds(like.batch_ids.length, (b: Uint32Array) => {
+    b.set(like.batch_ids);
+  });
+  t.setBatchIndices(like.batch_indices.length, (b: Uint32Array) => {
+    b.set(like.batch_indices);
+  });
+
+  return t;
+}

package/src/utils/toTransferablePolylineBatchedFeatureLike.ts

@@ -0,0 +1,21 @@
+import type { TransferablePolylineBatchedFeatureLike } from "@navaramap/core";
+import { TransferablePolylineBatchedFeature } from "@navaramap/engine-worker";
+
+export function toTransferablePolylineBatchedFeatureLike(
+  like: TransferablePolylineBatchedFeatureLike,
+) {
+  const t = new TransferablePolylineBatchedFeature(like.crs, like.length);
+  t.setPoints(like.points.length, (b: Float64Array) => {
+    b.set(like.points);
+  });
+  t.setPointsSizes(like.points_sizes.length, (b: Uint32Array) => {
+    b.set(like.points_sizes);
+  });
+  t.setBatchIds(like.batch_ids.length, (b: Uint32Array) => {
+    b.set(like.batch_ids);
+  });
+  t.setBatchIndices(like.batch_indices.length, (b: Uint32Array) => {
+    b.set(like.batch_indices);
+  });
+  return t;
+}

package/src/utils/toTransferableRasterDEMDataLike.ts

@@ -0,0 +1,22 @@
+import type { TransferableRasterDEMDataLike } from "@navaramap/core";
+import {
+  ElevationDecoder,
+  TransferableRasterDEMData,
+} from "@navaramap/engine-worker";
+
+export function toTransferableRasterDEMDataLike(
+  like: TransferableRasterDEMDataLike,
+) {
+  return new TransferableRasterDEMData(
+    new ElevationDecoder(
+      like.decoder.r_scaler,
+      like.decoder.g_scaler,
+      like.decoder.b_scaler,
+      like.decoder.offset,
+      like.decoder.max_offset,
+      like.decoder.min_offset,
+      like.decoder.boundary,
+      like.decoder.epsilon,
+    ),
+  );
+}

package/src/utils/toTransferableTileLike.ts

@@ -0,0 +1,34 @@
+import type {
+  TransferableTileLike,
+  TileXYZLike,
+  CachedMeshHandleLike,
+} from "@navaramap/core";
+import {
+  CachedMeshHandle,
+  TileXYZ,
+  TransferableTile,
+} from "@navaramap/engine-worker";
+
+export function toTransferableTile(like: TransferableTileLike) {
+  return new TransferableTile(
+    toTileXYZ(like.coords),
+    like.max_height,
+    like.min_height,
+    like.cached_mesh_handle
+      ? toCachedMeshHandle(like.cached_mesh_handle)
+      : undefined,
+  );
+}
+
+export function toTileXYZ(like: TileXYZLike) {
+  return new TileXYZ(like.x, like.y, like.z);
+}
+
+export function toCachedMeshHandle(like: CachedMeshHandleLike) {
+  return new CachedMeshHandle(
+    like.vertices,
+    like.indices,
+    like.uvs,
+    like.heights,
+  );
+}

package/src/utils/toUpsamplableTerrainGeometryLike.ts

@@ -0,0 +1,14 @@
+import type { UpsamplableTerrainGeometryLike } from "@navaramap/core";
+import { UpsamplableTerrainGeometry } from "@navaramap/engine-worker";
+
+export function toUpsamplableTerrainGeometry(
+  like: UpsamplableTerrainGeometryLike,
+) {
+  return new UpsamplableTerrainGeometry(
+    like.uvs,
+    like.indices,
+    like.heights,
+    like.normals,
+    like.watermask,
+  );
+}

package/src/utils/toVec3Like.ts

@@ -0,0 +1,6 @@
+import { Vec3Like } from "@navaramap/core";
+import { Vec3 } from "@navaramap/engine-worker";
+
+export function toVec3Like(like: Vec3) {
+  return new Vec3Like(like);
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/src/worker/index.ts

@@ -0,0 +1,44 @@
+import workerpool from "workerpool";
+
+import { commonTasks } from "../tasks";
+
+export { type CommonTasks } from "../tasks";
+
+export * from "./transfer";
+
+let isInitialized = false;
+export const registerTasks = (
+  ...args: Parameters<typeof workerpool.worker>
+) => {
+  if (!isInitialized) {
+    workerpool.worker(commonTasks);
+    keepWorkerAliveOnAbort();
+    isInitialized = true;
+  }
+  return workerpool.worker(...args);
+};
+
+/**
+ * Register a no-op abort listener so a cancelled task does not terminate this
+ * worker. Without any listener, workerpool kills the worker on
+ * cancel-while-running and the next task pays a fresh WASM cold start
+ * (`minWorkers: 0`, so nothing re-warms it) — expensive under fast camera
+ * movement, where cancellations are routine. A synchronous WASM task cannot
+ * be interrupted anyway; letting it finish and dropping the result costs the
+ * same compute while keeping the warm worker in the pool.
+ *
+ * workerpool exposes `addAbortListener` only as a `worker` property it
+ * attaches to each registered method (`worker.methods[name].worker`), hence
+ * the lookup through a just-registered task.
+ *
+ * This only works together with the pool-side `workerTerminateTimeout` (see
+ * `recyclingPool.ts`): the busy worker cannot even receive the cleanup
+ * message until the running task finishes, so with the 1s default the pool
+ * would force-terminate it anyway for any task with more than ~1s remaining.
+ */
+function keepWorkerAliveOnAbort() {
+  const registered = commonTasks.warmUp as {
+    worker?: { addAbortListener: (listener: () => Promise<void>) => void };
+  };
+  registered.worker?.addAbortListener(async () => {});
+}

package/src/worker/transfer.ts

@@ -0,0 +1,6 @@
+import workerpool from "workerpool";
+
+export const transfer = <T extends object>(
+  message: T,
+  transfer: Transferable[],
+) => new workerpool.Transfer(message, transfer) as T;