@navaramap/core 0.0.0

package/src/utils/ExtentRadianF32Like.ts

@@ -0,0 +1,17 @@
+import type { ExtentRadianF32 } from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+export class ExtentRadianF32Like implements RemoveFreeRecursively<ExtentRadianF32> {
+  east: number;
+  north: number;
+  south: number;
+  west: number;
+
+  constructor(t: ExtentRadianF32) {
+    this.east = t.east;
+    this.north = t.north;
+    this.south = t.south;
+    this.west = t.west;
+  }
+}

package/src/utils/FloatAttributeLike.ts

@@ -0,0 +1,17 @@
+import type { FloatAttribute } from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+export class FloatAttributeLike implements RemoveFreeRecursively<FloatAttribute> {
+  data: Float32Array;
+  size: number;
+
+  constructor(t: FloatAttribute) {
+    this.data = t.transferData();
+    this.size = t.size;
+  }
+
+  transferData(): Float32Array {
+    throw new Error();
+  }
+}

package/src/utils/ReturnedConstructedTerrainMeshLike.ts

@@ -0,0 +1,92 @@
+import type { ReturnedConstructedTerrainMesh } from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+import { Vec3Like } from "./Vec3Like";
+
+export class ReturnedConstructedTerrainMeshLike implements RemoveFreeRecursively<ReturnedConstructedTerrainMesh> {
+  vertices: Float32Array;
+  uvs: Float32Array;
+  indices: Uint32Array;
+  heights: Float32Array;
+  max_height: number;
+  min_height: number;
+  rtc_translation: Vec3Like | undefined;
+  normals: Float32Array | undefined;
+  skirt_vertices: Float32Array | undefined;
+  skirt_uvs: Float32Array | undefined;
+  skirt_indices: Uint32Array | undefined;
+  skirt_normals: Float32Array | undefined;
+  watermask: Uint8Array | undefined;
+
+  // The transfer* methods return arrays copied out of WASM memory (owned by
+  // JS, backed by their own ArrayBuffer), so they are retained and transferred
+  // as-is — a further copy (`.slice()`) would be redundant.
+  constructor(t: ReturnedConstructedTerrainMesh) {
+    this.vertices = t.transferVertices();
+    this.uvs = t.transferUvs();
+    this.indices = t.transferIndices();
+    this.heights = t.transferHeights();
+    this.max_height = t.max_height;
+    this.min_height = t.min_height;
+    this.rtc_translation = t.rtc_translation
+      ? new Vec3Like(t.rtc_translation)
+      : undefined;
+    if (t.hasNormals()) {
+      this.normals = t.transferNormals();
+    }
+    if (t.hasSkirt()) {
+      this.skirt_vertices = t.transferSkirtVertices();
+      this.skirt_uvs = t.transferSkirtUvs();
+      this.skirt_indices = t.transferSkirtIndices();
+      this.skirt_normals = t.transferSkirtNormals();
+    }
+    if (t.hasWatermask()) {
+      this.watermask = t.transferWatermask();
+    }
+  }
+
+  transferVertices(): Float32Array {
+    throw new Error();
+  }
+  transferUvs(): Float32Array {
+    throw new Error();
+  }
+  transferIndices(): Uint32Array {
+    throw new Error();
+  }
+  transferHeights(): Float32Array {
+    throw new Error();
+  }
+  transferNormals(): Float32Array | undefined {
+    throw new Error();
+  }
+  transferSkirtVertices(): Float32Array | undefined {
+    throw new Error();
+  }
+  transferSkirtUvs(): Float32Array | undefined {
+    throw new Error();
+  }
+  transferSkirtIndices(): Uint32Array | undefined {
+    throw new Error();
+  }
+  transferSkirtNormals(): Float32Array | undefined {
+    throw new Error();
+  }
+  transferWatermask(): Uint8Array | undefined {
+    throw new Error();
+  }
+  hasSkirt(): boolean {
+    return (
+      this.skirt_vertices !== undefined &&
+      this.skirt_uvs !== undefined &&
+      this.skirt_indices !== undefined
+    );
+  }
+  hasNormals(): boolean {
+    return this.normals !== undefined;
+  }
+  hasWatermask(): boolean {
+    return this.watermask !== undefined;
+  }
+}

package/src/utils/TransferableMartiniLike.ts

@@ -0,0 +1,21 @@
+import type { TransferableMartini } from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+export class TransferableMartiniLike implements RemoveFreeRecursively<TransferableMartini> {
+  coords: Uint32Array;
+  size: number;
+
+  constructor(coords: Uint32Array, size: number) {
+    this.coords = coords;
+    this.size = size;
+  }
+
+  transfer_coords(): Uint32Array {
+    return this.coords;
+  }
+
+  clone() {
+    return new TransferableMartiniLike(this.coords.slice(), this.size);
+  }
+}

package/src/utils/TransferableRasterDEMDataLike.ts

@@ -0,0 +1,36 @@
+import type {
+  ElevationDecoder,
+  TransferableRasterDEMData,
+} from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+export class TransferableRasterDEMDataLike implements RemoveFreeRecursively<TransferableRasterDEMData> {
+  decoder: ElevationDecoderLike;
+
+  constructor(decoder: ElevationDecoder) {
+    this.decoder = new ElevationDecoderLike(decoder);
+  }
+}
+
+export class ElevationDecoderLike implements RemoveFreeRecursively<ElevationDecoder> {
+  b_scaler: number;
+  boundary: number;
+  epsilon: number;
+  g_scaler: number;
+  max_offset: number;
+  min_offset: number;
+  offset: number;
+  r_scaler: number;
+
+  constructor(t: ElevationDecoder) {
+    this.b_scaler = t.b_scaler;
+    this.boundary = t.boundary;
+    this.epsilon = t.epsilon;
+    this.g_scaler = t.g_scaler;
+    this.max_offset = t.max_offset;
+    this.min_offset = t.min_offset;
+    this.offset = t.offset;
+    this.r_scaler = t.r_scaler;
+  }
+}

package/src/utils/TransferableTileLike.ts

@@ -0,0 +1,53 @@
+import type {
+  CachedMeshHandle,
+  TileXYZ,
+  TransferableTile,
+} from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+export class TransferableTileLike {
+  cached_mesh_handle?: CachedMeshHandleLike | undefined;
+  coords: TileXYZLike;
+  max_height: number;
+  min_height: number;
+
+  constructor(t: TransferableTile) {
+    this.cached_mesh_handle = t.cached_mesh_handle
+      ? new CachedMeshHandleLike(t.cached_mesh_handle)
+      : undefined;
+    this.coords = new TileXYZLike(t.coords);
+    this.max_height = t.max_height;
+    this.min_height = t.min_height;
+  }
+
+  free(): void {}
+}
+
+export class TileXYZLike implements RemoveFreeRecursively<TileXYZ> {
+  x: number;
+  y: number;
+  z: number;
+
+  constructor(t: TileXYZ) {
+    this.x = t.x;
+    this.y = t.y;
+    this.z = t.z;
+  }
+}
+
+export class CachedMeshHandleLike {
+  vertices: number;
+  uvs: number;
+  indices: number;
+  heights?: number | undefined;
+
+  constructor(t: CachedMeshHandle) {
+    this.vertices = t.vertices;
+    this.uvs = t.uvs;
+    this.indices = t.indices;
+    this.heights = t.heights;
+  }
+
+  free(): void {}
+}

package/src/utils/UpsamplableTerrainGeometryLike.ts

@@ -0,0 +1,26 @@
+import type { UpsamplableTerrainGeometry } from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+export class UpsamplableTerrainGeometryLike implements RemoveFreeRecursively<UpsamplableTerrainGeometry> {
+  uvs: Float32Array;
+  indices: Uint32Array;
+  heights: Float32Array;
+  normals: Float32Array | undefined;
+  /** Parent quantized-mesh watermask (1 byte uniform or 65536 byte 256x256 grid). */
+  watermask: Uint8Array | undefined;
+
+  constructor(
+    uvs: Float32Array,
+    indices: Uint32Array,
+    heights: Float32Array,
+    normals?: Float32Array,
+    watermask?: Uint8Array,
+  ) {
+    this.uvs = uvs;
+    this.indices = indices;
+    this.heights = heights;
+    this.normals = normals;
+    this.watermask = watermask;
+  }
+}

package/src/utils/Vec3Like.ts

@@ -0,0 +1,15 @@
+import type { Vec3 } from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../types";
+
+export class Vec3Like implements RemoveFreeRecursively<Vec3> {
+  x: number;
+  y: number;
+  z: number;
+
+  constructor(t: Vec3) {
+    this.x = t.x;
+    this.y = t.y;
+    this.z = t.z;
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export * from "./TransferableTileLike";
+export * from "./TransferableMartiniLike";
+export * from "./UpsamplableTerrainGeometryLike";
+export * from "./TransferableRasterDEMDataLike";
+export * from "./ReturnedConstructedTerrainMeshLike";
+export * from "./polygon";
+export * from "./polyline";
+export * from "./ExtentRadianF32Like";
+export * from "./Vec3Like";

package/src/utils/polygon/ConstructedPolygonGeometryLike.ts

@@ -0,0 +1,70 @@
+import type { ConstructedPolygonGeometry } from "@navaramap/engine";
+
+import { ExtentRadianF32Like } from "../ExtentRadianF32Like";
+import { Vec3Like } from "../Vec3Like";
+
+export class ConstructedPolygonGeometryLike {
+  extent: ExtentRadianF32Like | undefined;
+  position_3d_high: Float32Array | undefined;
+  position_3d_high_size: number | undefined;
+  position_3d_low: Float32Array | undefined;
+  position_3d_low_size: number | undefined;
+  position: Float32Array | undefined;
+  position_size: number | undefined;
+  normal: Float32Array | undefined;
+  normal_size: number | undefined;
+  scale_normal_and_cap: Float32Array | undefined;
+  scale_normal_and_cap_size: number | undefined;
+  batch_id: Float32Array | undefined;
+  batch_id_size: number | undefined;
+  batch_index: Uint32Array | undefined;
+  batch_index_size: number | undefined;
+  indices: Uint32Array;
+  /** RTC (Relative-To-Center) translation vector in world-space ECEF coordinates */
+  rtc_translation: Vec3Like | undefined;
+  outline_position: Float32Array | undefined;
+  outline_position_size: number | undefined;
+  outline_scale_normal_and_cap: Float32Array | undefined;
+  outline_scale_normal_and_cap_size: number | undefined;
+  outline_skip_indices: Uint32Array | undefined;
+  outline_batch_index: Float32Array | undefined;
+  outline_batch_index_size: number | undefined;
+
+  constructor(t: ConstructedPolygonGeometry) {
+    const extent = t.extent;
+    this.extent = extent ? new ExtentRadianF32Like(extent) : undefined;
+    // Need to make a slice to avoid memory leak due to it's transferred.
+    this.position_3d_high = t.position_3d_high()?.slice();
+    this.position_3d_high_size = t.position_3d_high_size();
+    this.position_3d_low = t.position_3d_low()?.slice();
+    this.position_3d_low_size = t.position_3d_low_size();
+    this.position = t.position()?.slice();
+    this.position_size = t.position_size();
+    this.normal = t.normal()?.slice();
+    this.normal_size = t.normal_size();
+    this.scale_normal_and_cap = t.scale_normal_and_cap()?.slice();
+    this.scale_normal_and_cap_size = t.scale_normal_and_cap_size();
+    this.batch_id = t.batch_id()?.slice();
+    this.batch_id_size = t.batch_id_size();
+    this.batch_index = t.batch_index()?.slice();
+    this.batch_index_size = t.batch_index_size();
+    this.indices = t.indices().slice();
+    this.rtc_translation = t.rtc_translation
+      ? new Vec3Like(t.rtc_translation)
+      : undefined;
+    const outline = t.outline();
+    if (outline) {
+      this.outline_position = outline.position()?.slice();
+      this.outline_position_size = outline.position_size();
+      this.outline_scale_normal_and_cap = outline
+        .scale_normal_and_cap()
+        ?.slice();
+      this.outline_scale_normal_and_cap_size =
+        outline.scale_normal_and_cap_size();
+      this.outline_skip_indices = outline.skip_indices()?.slice();
+      this.outline_batch_index = outline.batch_index()?.slice();
+      this.outline_batch_index_size = outline.batch_index_size();
+      outline.free();
+    }
+  }
+}

package/src/utils/polygon/PolygonMaterialLike.ts

@@ -0,0 +1,37 @@
+import type {
+  PolygonInternalMaterial,
+  PolygonMaterial,
+} from "@navaramap/engine";
+
+export class PolygonMaterialLike {
+  clampToGround?: boolean;
+  tiled?: boolean;
+  castShadow?: boolean;
+  receiveShadow?: boolean;
+  color?: number;
+  extrudedHeight?: number;
+  height?: number;
+  show?: boolean;
+  perPositionHeight?: boolean;
+  wireframe?: boolean;
+  outline?: boolean;
+  __internal__?: PolygonInternalMaterial | undefined;
+
+  constructor(material: PolygonMaterial) {
+    this.clampToGround = material.clampToGround;
+    this.tiled = material.tiled;
+    this.receiveShadow = material.receiveShadow;
+    this.castShadow = material.castShadow;
+    this.color = material.color;
+    this.extrudedHeight = material.extrudedHeight;
+    this.height = material.height;
+    this.show = material.show;
+
+    this.perPositionHeight = material.perPositionHeight;
+
+    this.wireframe = material.wireframe;
+    this.outline = material.outline;
+  }
+
+  free(): void {}
+}

package/src/utils/polygon/TransferablePolygonBatchedFeatureLike.ts

@@ -0,0 +1,73 @@
+import type {
+  CRS,
+  ReturnedTransferablePolygonBatchedFeature,
+  TransferablePolygonBatchedFeature,
+} from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../../types";
+
+export class TransferablePolygonBatchedFeatureLike implements RemoveFreeRecursively<TransferablePolygonBatchedFeature> {
+  batch_ids: Uint32Array;
+  batch_indices: Uint32Array;
+  crs: CRS;
+  expected_winding_orders: Uint8Array;
+  holes: Float64Array;
+  holes_boundaries: Uint32Array;
+  holes_sizes: Uint32Array;
+  holes_total_sizes: Uint32Array;
+  length: number;
+  outer_ring: Float64Array;
+  outer_ring_sizes: Uint32Array;
+
+  constructor(t: ReturnedTransferablePolygonBatchedFeature) {
+    this.batch_ids = t.transferBatchIds();
+    this.batch_indices = t.transferBatchIndices();
+    this.crs = t.crs();
+    this.expected_winding_orders = t.transferExpectedWindingOrders();
+    this.holes = t.transferHoles();
+    this.holes_boundaries = t.transferHolesBoundaries();
+    this.holes_sizes = t.transferHolesSizes();
+    this.holes_total_sizes = t.transferHolesTotalSizes();
+    this.length = t.length();
+    this.outer_ring = t.transferOuterRing();
+    this.outer_ring_sizes = t.transferOuterRingSizes();
+  }
+
+  setBatchIds(_length: number, _f: () => void) {}
+  setBatchIndices(_length: number, _f: () => void) {}
+  setExpectedWindingOrders(_length: number, _f: () => void) {}
+  setOuterRing(_length: number, _f: () => void) {}
+  setOuterRingSizes(_length: number, _f: () => void) {}
+  setHoles(_length: number, _f: () => void) {}
+  setHolesBoundaries(_length: number, _f: () => void) {}
+  setHolesSizes(_length: number, _f: () => void) {}
+  setHolesTotalSizes(_length: number, _f: () => void) {}
+
+  transferBatchIds(): Uint32Array {
+    throw new Error();
+  }
+  transferBatchIndices(): Uint32Array {
+    throw new Error();
+  }
+  transferExpectedWindingOrders(): Uint8Array {
+    throw new Error();
+  }
+  transferOuterRing(): Float64Array {
+    throw new Error();
+  }
+  transferOuterRingSizes(): Uint32Array {
+    throw new Error();
+  }
+  transferHoles(): Float64Array {
+    throw new Error();
+  }
+  transferHolesBoundaries(): Uint32Array {
+    throw new Error();
+  }
+  transferHolesSizes(): Uint32Array {
+    throw new Error();
+  }
+  transferHolesTotalSizes(): Uint32Array {
+    throw new Error();
+  }
+}

package/src/utils/polygon/index.ts

@@ -0,0 +1,3 @@
+export * from "./TransferablePolygonBatchedFeatureLike";
+export * from "./PolygonMaterialLike";
+export * from "./ConstructedPolygonGeometryLike";

package/src/utils/polyline/ConstructedPolylineGeometryLike.ts

@@ -0,0 +1,77 @@
+import type { ConstructedPolylineGeometry } from "@navaramap/engine";
+
+import { ExtentRadianF32Like } from "../ExtentRadianF32Like";
+
+export class ConstructedPolylineGeometryLike {
+  extent: ExtentRadianF32Like | undefined;
+  position: Float32Array;
+  position_size: number;
+  position_high: Float32Array | undefined;
+  position_high_size: number | undefined;
+  position_low: Float32Array | undefined;
+  position_low_size: number | undefined;
+  start: Float32Array | undefined;
+  start_size: number | undefined;
+  start_high: Float32Array | undefined;
+  start_high_size: number | undefined;
+  start_low: Float32Array | undefined;
+  start_low_size: number | undefined;
+  forward_offset: Float32Array | undefined;
+  forward_offset_size: number | undefined;
+  end_high: Float32Array | undefined;
+  end_high_size: number | undefined;
+  end_low: Float32Array | undefined;
+  end_low_size: number | undefined;
+  start_normals: Float32Array | undefined;
+  start_normals_size: number | undefined;
+  end_normal_and_texture_coordinate_normalization_x: Float32Array | undefined;
+  end_normal_and_texture_coordinate_normalization_x_size: number | undefined;
+  right_normal_and_texture_coordinate_normalization_y: Float32Array;
+  right_normal_and_texture_coordinate_normalization_y_size: number;
+  batch_id: Float32Array | undefined;
+  batch_id_size: number | undefined;
+  batch_index: Uint32Array | undefined;
+  batch_index_size: number | undefined;
+  indices: Uint32Array;
+
+  constructor(t: ConstructedPolylineGeometry) {
+    const extent = t.extent;
+    this.extent = extent ? new ExtentRadianF32Like(extent) : undefined;
+    // Need to make a slice to avoid memory leak due to it's transferred.
+    this.position = t.position().slice();
+    this.position_size = t.position_size();
+    this.position_high = t.position_high()?.slice();
+    this.position_high_size = t.position_high_size();
+    this.position_low = t.position_low()?.slice();
+    this.position_low_size = t.position_low_size();
+    this.start = t.start()?.slice();
+    this.start_size = t.start_size();
+    this.start_high = t.start_high()?.slice();
+    this.start_high_size = t.start_high_size();
+    this.start_low = t.start_low()?.slice();
+    this.start_low_size = t.start_low_size();
+    this.forward_offset = t.forward_offset()?.slice();
+    this.forward_offset_size = t.forward_offset_size();
+    this.end_high = t.end_high()?.slice();
+    this.end_high_size = t.end_high_size();
+    this.end_low = t.end_low()?.slice();
+    this.end_low_size = t.end_low_size();
+    this.start_normals = t.start_normals()?.slice();
+    this.start_normals_size = t.start_normals_size();
+    this.end_normal_and_texture_coordinate_normalization_x = t
+      .end_normal_and_texture_coordinate_normalization_x()
+      ?.slice();
+    this.end_normal_and_texture_coordinate_normalization_x_size =
+      t.end_normal_and_texture_coordinate_normalization_x_size();
+    this.right_normal_and_texture_coordinate_normalization_y = t
+      .right_normal_and_texture_coordinate_normalization_y()
+      .slice();
+    this.right_normal_and_texture_coordinate_normalization_y_size =
+      t.right_normal_and_texture_coordinate_normalization_y_size();
+    this.batch_id = t.batch_id()?.slice();
+    this.batch_id_size = t.batch_id_size();
+    this.batch_index = t.batch_index()?.slice();
+    this.batch_index_size = t.batch_index_size();
+    this.indices = t.indices().slice();
+  }
+}

package/src/utils/polyline/PolylineMaterialLike.ts

@@ -0,0 +1,31 @@
+import type {
+  PolylineInternalMaterial,
+  PolylineMaterial,
+} from "@navaramap/engine";
+
+export class PolylineMaterialLike {
+  clampToGround?: boolean;
+  tiled?: boolean;
+  castShadow?: boolean;
+  receiveShadow?: boolean;
+  color?: number;
+  height?: number;
+  width?: number;
+  maxWidth?: number;
+  show?: boolean;
+  __internal__?: PolylineInternalMaterial;
+
+  constructor(material: PolylineMaterial) {
+    this.clampToGround = material.clampToGround;
+    this.tiled = material.tiled;
+    this.receiveShadow = material.receiveShadow;
+    this.castShadow = material.castShadow;
+    this.color = material.color;
+    this.width = material.width;
+    this.maxWidth = material.maxWidth;
+    this.height = material.height;
+    this.show = material.show;
+  }
+
+  free(): void {}
+}

package/src/utils/polyline/TransferablePolylineBatchedFeatureLike.ts

@@ -0,0 +1,43 @@
+import type {
+  CRS,
+  ReturnedTransferablePolylineBatchedFeature,
+  TransferablePolylineBatchedFeature,
+} from "@navaramap/engine";
+
+import type { RemoveFreeRecursively } from "../../types";
+
+export class TransferablePolylineBatchedFeatureLike implements RemoveFreeRecursively<TransferablePolylineBatchedFeature> {
+  points: Float64Array;
+  points_sizes: Uint32Array;
+  batch_ids: Uint32Array;
+  batch_indices: Uint32Array;
+  crs: CRS;
+  length: number;
+
+  constructor(t: ReturnedTransferablePolylineBatchedFeature) {
+    this.points = t.transferPoints();
+    this.points_sizes = t.transferPointsSizes();
+    this.batch_ids = t.transferBatchIds();
+    this.batch_indices = t.transferBatchIndices();
+    this.crs = t.crs();
+    this.length = t.length();
+  }
+
+  setPoints(_byte_length: number, _f: () => void): void {}
+  setPointsSizes(_byte_length: number, _f: () => void): void {}
+  setBatchIds(_byte_length: number, _f: () => void): void {}
+  setBatchIndices(_length: number, _f: () => void) {}
+
+  transferPoints(): Float64Array {
+    throw new Error();
+  }
+  transferPointsSizes(): Uint32Array {
+    throw new Error();
+  }
+  transferBatchIds(): Uint32Array {
+    throw new Error();
+  }
+  transferBatchIndices(): Uint32Array {
+    throw new Error();
+  }
+}

package/src/utils/polyline/index.ts

@@ -0,0 +1,3 @@
+export * from "./TransferablePolylineBatchedFeatureLike";
+export * from "./PolylineMaterialLike";
+export * from "./ConstructedPolylineGeometryLike";

package/src/vite-env.d.ts

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