@navaramap/three 0.0.0

package/src/renderOrder.ts

@@ -0,0 +1,3 @@
+export const FEATURE_RENDER_ORDER = 1;
+export const SKY_RENDER_ORDER = 100;
+export const STARS_RENDER_ORDER = SKY_RENDER_ORDER + 1;

package/src/scene.test.ts

@@ -0,0 +1,164 @@
+import { Mesh, BoxGeometry, MeshBasicMaterial } from "three";
+import { describe, it, expect, vi } from "vitest";
+
+import { TexturizedSceneByTileCoordinates, TileScene } from "./scene";
+
+function createMockRenderer() {
+  return {
+    getContext: vi.fn(),
+    getPixelRatio: vi.fn().mockReturnValue(1),
+    getSize: vi.fn(),
+    setSize: vi.fn(),
+    render: vi.fn(),
+  } as unknown as ConstructorParameters<
+    typeof TexturizedSceneByTileCoordinates
+  >[0];
+}
+
+function createMesh(): Mesh {
+  return new Mesh(new BoxGeometry(1, 1, 1), new MeshBasicMaterial());
+}
+
+function getGroup(ts: TexturizedSceneByTileCoordinates, handle: bigint) {
+  const group = ts.map.get(handle);
+  if (!group) throw new Error("group not found");
+  return group;
+}
+
+describe("add", () => {
+  it("add creates a new TileScene with layerId inside SceneGroup", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+    const mesh = createMesh();
+
+    ts.add(handle, "layer-a", mesh, 0);
+
+    const group = getGroup(ts, handle);
+    expect(group.tileScenes).toHaveLength(1);
+    expect(group.tileScenes[0].layerId).toBe("layer-a");
+    expect(group.tileScenes[0]).toBeInstanceOf(TileScene);
+  });
+
+  it("add with same layerId reuses existing Scene", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+
+    ts.add(handle, "layer-a", createMesh(), 0);
+    ts.add(handle, "layer-a", createMesh(), 0);
+
+    const group = getGroup(ts, handle);
+    expect(group.tileScenes).toHaveLength(1);
+    expect(group.tileScenes[0].children).toHaveLength(2);
+  });
+
+  it("scenes are sorted by layerIndex", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+
+    ts.add(handle, "c", createMesh(), 2);
+    ts.add(handle, "b", createMesh(), 1);
+    ts.add(handle, "a", createMesh(), 0);
+
+    const group = getGroup(ts, handle);
+    expect(group.tileScenes.map((c) => c.layerIndex)).toEqual([0, 1, 2]);
+    expect(group.tileScenes.map((c) => c.layerId)).toEqual(["a", "b", "c"]);
+  });
+
+  it("revision increments on add", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+
+    ts.add(handle, "layer-a", createMesh(), 0);
+    const scene = ts.findSceneByLayerId(handle, "layer-a");
+    expect(scene?.revision).toBe(1);
+
+    ts.add(handle, "layer-a", createMesh(), 0);
+    expect(scene?.revision).toBe(2);
+  });
+
+  it("removeMesh removes only that mesh, keeping siblings, and bumps revision", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+    const a = createMesh();
+    const b = createMesh();
+
+    ts.add(handle, "layer-a", a, 0);
+    ts.add(handle, "layer-a", b, 0);
+    const scene = ts.findSceneByLayerId(handle, "layer-a");
+    const revBefore = scene?.revision ?? 0;
+
+    ts.removeMesh(handle, "layer-a", a);
+
+    expect(scene?.children).toHaveLength(1);
+    expect(scene?.children[0]).toBe(b);
+    expect(scene?.removed).toBe(false);
+    expect(scene?.revision).toBe(revBefore + 1);
+  });
+
+  it("removeMesh prunes the empty TileScene and SceneGroup once the last mesh leaves", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+    const a = createMesh();
+
+    ts.add(handle, "layer-a", a, 0);
+    const scene = ts.findSceneByLayerId(handle, "layer-a");
+
+    ts.removeMesh(handle, "layer-a", a);
+
+    expect(scene?.removed).toBe(true);
+    // The empty scene group is pruned from the map (no leak).
+    expect(ts.map.has(handle)).toBe(false);
+  });
+
+  it("delete removes the entire SceneGroup for a tile handle", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+
+    ts.add(handle, "layer-a", createMesh(), 0);
+    ts.delete(handle);
+
+    expect(ts.map.has(handle)).toBe(false);
+  });
+});
+
+describe("findSceneByLayerId", () => {
+  it("returns the TileScene for a known layerId", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+
+    ts.add(handle, "layer-a", createMesh(), 0);
+
+    const scene = ts.findSceneByLayerId(handle, "layer-a");
+    expect(scene).toBeInstanceOf(TileScene);
+    expect(scene?.layerId).toBe("layer-a");
+  });
+
+  it("returns undefined for unknown layerId", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+
+    expect(ts.findSceneByLayerId(1n, "nonexistent")).toBeUndefined();
+  });
+});
+
+describe("markDirty", () => {
+  it("bumps the layer scene's revision without changing children", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+    const handle = 1n;
+
+    ts.add(handle, "layer-a", createMesh(), 0);
+    const scene = ts.findSceneByLayerId(handle, "layer-a");
+    const revBefore = scene?.revision ?? 0;
+    const childrenBefore = scene?.children.length ?? 0;
+
+    ts.markDirty(handle, "layer-a");
+
+    expect(scene?.revision).toBe(revBefore + 1);
+    expect(scene?.children.length).toBe(childrenBefore);
+  });
+
+  it("is a no-op for an unknown handle/layerId", () => {
+    const ts = new TexturizedSceneByTileCoordinates(createMockRenderer());
+
+    expect(() => ts.markDirty(999n, "nonexistent")).not.toThrow();
+  });
+});

package/src/scene.ts

@@ -0,0 +1,127 @@
+import type { TileHandle } from "@navaramap/core";
+import { OrthographicCamera, Scene, WebGLRenderer, Mesh, Group } from "three";
+
+export type Scenes = {
+  // Render light in all scenes.
+  light: Group;
+  // Render general mesh to MRT. The mesh added to this scene needs a normal buffer.
+  mrt: Scene;
+  // Render only globe.
+  globe: Scene;
+  // Render only draped mesh on the globe
+  draped: Scene;
+  // Render this scene at last. This scene should not be handled in MRT.
+  opaque: Scene;
+  // Render this scene after the atmosphere effect. This scene should not be handled in MRT.
+  // It is useful to render a transparent mesh.
+  transparent: Scene;
+  // Render sky environment map to a cube map for reflections
+  skyEnvMap: Scene;
+};
+
+export class TileScene extends Scene {
+  layerId: string;
+  layerIndex: number;
+  removed = false;
+  revision = 0;
+
+  constructor(layerId: string, layerIndex: number) {
+    super();
+    this.layerId = layerId;
+    this.layerIndex = layerIndex;
+  }
+}
+
+export class SceneGroup extends Group {
+  get tileScenes(): TileScene[] {
+    return this.children as TileScene[];
+  }
+}
+
+export class TexturizedSceneByTileCoordinates {
+  map = new Map<TileHandle, SceneGroup>();
+  renderer: WebGLRenderer;
+  camera: OrthographicCamera;
+
+  constructor(renderer: WebGLRenderer) {
+    this.renderer = renderer;
+    this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    this.camera.position.z = 1;
+  }
+
+  get(handle: TileHandle) {
+    let scene = this.map.get(handle);
+    if (!scene) {
+      scene = new SceneGroup();
+      this.map.set(handle, scene);
+    }
+    return scene;
+  }
+
+  private findTileScene(
+    handle: TileHandle,
+    layerId: string,
+  ): TileScene | undefined {
+    return this.map.get(handle)?.tileScenes.find((o) => o.layerId === layerId);
+  }
+
+  add(handle: TileHandle, layerId: string, mesh: Mesh, layerIndex: number) {
+    const scenes = this.get(handle);
+    let scene = this.findTileScene(handle, layerId);
+    if (!scene) {
+      scene = new TileScene(layerId, layerIndex);
+      scenes.add(scene);
+      scenes.tileScenes.sort((a, b) => a.layerIndex - b.layerIndex);
+    }
+
+    scene.removed = false;
+
+    scene.add(mesh);
+    scene.revision++;
+
+    return scene;
+  }
+
+  findSceneByLayerId(handle: TileHandle, layerId: string) {
+    return this.findTileScene(handle, layerId);
+  }
+
+  /**
+   * Bump a layer scene's revision without changing its contents. Draped-feature
+   * material/visibility changes that don't add or remove a mesh use this so the
+   * consuming TileMesh's bake signature (which folds in `revision`) re-bakes.
+   */
+  markDirty(handle: TileHandle, layerId: string) {
+    const scene = this.findTileScene(handle, layerId);
+    if (!scene) return;
+    scene.revision++;
+  }
+
+  /**
+   * Remove a single feature mesh from its (tile, layer) scene. Only when the scene's last
+   * mesh leaves do we mark it `removed` and prune the empty `TileScene` (and the
+   * `SceneGroup` if it too becomes empty). This keeps sibling draped features in the same
+   * tile+layer intact — unlike a whole-scene clear, which blanked them all on one removal.
+   */
+  removeMesh(handle: TileHandle, layerId: string, mesh: Mesh) {
+    const scene = this.findTileScene(handle, layerId);
+    if (!scene) return;
+    scene.remove(mesh);
+    scene.revision++;
+    if (scene.children.length === 0) {
+      scene.removed = true;
+      const group = this.map.get(handle);
+      group?.remove(scene);
+      if (group && group.tileScenes.length === 0) this.delete(handle);
+    }
+  }
+
+  delete(handle: TileHandle) {
+    const sceneGroup = this.map.get(handle);
+    if (!sceneGroup) return;
+
+    sceneGroup.clear();
+
+    this.map.delete(handle);
+  }
+}

package/src/shaders/index.ts

@@ -0,0 +1 @@
+export * from "@takram/three-geospatial/shaders";

package/src/solar.test.ts

@@ -0,0 +1,81 @@
+import { AstroTime, Body, HourAngle, Observer } from "astronomy-engine";
+import { describe, expect, it } from "vitest";
+
+import {
+  getSunElevation,
+  shiftDateToElevation,
+  shiftDateToHourAngle,
+} from "./solar";
+
+// Summer solstice — well-defined sun positions at all test locations
+const BASE_DATE = new Date("2024-06-21T00:00:00Z");
+
+function sunHourAngle(date: Date, lng: number): number {
+  return HourAngle(Body.Sun, new AstroTime(date), new Observer(0, lng, 0));
+}
+
+describe("shiftDateToHourAngle", () => {
+  it("preserves hour angle when moving from Tokyo to London", () => {
+    const haBefore = sunHourAngle(BASE_DATE, 139.69);
+    const result = shiftDateToHourAngle(BASE_DATE, 139.69, -0.12);
+    expect(sunHourAngle(result, -0.12)).toBeCloseTo(haBefore, 2);
+  });
+
+  it("preserves hour angle when moving from London to New York", () => {
+    const date = new Date("2024-06-21T08:00:00Z");
+    const haBefore = sunHourAngle(date, -0.12);
+    const result = shiftDateToHourAngle(date, -0.12, -74.01);
+    expect(sunHourAngle(result, -74.01)).toBeCloseTo(haBefore, 2);
+  });
+
+  it("is a no-op when target longitude equals source longitude", () => {
+    const result = shiftDateToHourAngle(BASE_DATE, 139.69, 139.69);
+    expect(result.getTime()).toBeCloseTo(BASE_DATE.getTime(), -3); // within ~1s
+  });
+
+  it("handles crossing the date line (Tokyo → Honolulu)", () => {
+    const haBefore = sunHourAngle(BASE_DATE, 139.69);
+    const result = shiftDateToHourAngle(BASE_DATE, 139.69, -157.85);
+    expect(sunHourAngle(result, -157.85)).toBeCloseTo(haBefore, 2);
+  });
+});
+
+describe("shiftDateToElevation", () => {
+  it("preserves sun elevation when moving from Tokyo to London (morning)", () => {
+    // ~8 AM solar at Tokyo
+    const date = new Date("2024-06-20T22:40:00Z");
+    const elevBefore = getSunElevation(date, 35.68, 139.69);
+    const result = shiftDateToElevation(date, 35.68, 139.69, 51.5, -0.12);
+    expect(getSunElevation(result, 51.5, -0.12)).toBeCloseTo(elevBefore, 1);
+  });
+
+  it("preserves sun elevation when moving from Tokyo to London (afternoon)", () => {
+    // ~4 PM solar at Tokyo
+    const date = new Date("2024-06-21T07:00:00Z");
+    const elevBefore = getSunElevation(date, 35.68, 139.69);
+    const result = shiftDateToElevation(date, 35.68, 139.69, 51.5, -0.12);
+    expect(getSunElevation(result, 51.5, -0.12)).toBeCloseTo(elevBefore, 1);
+  });
+
+  it("clamps to solar noon when target elevation exceeds location maximum", () => {
+    // High elevation at equator around noon in December — unreachable at Reykjavik (~3° max)
+    const date = new Date("2024-12-21T12:00:00Z");
+    const result = shiftDateToElevation(date, 0, 0, 64.1, -22.0);
+    expect(result).toBeInstanceOf(Date);
+    expect(isNaN(result.getTime())).toBe(false);
+  });
+});
+
+describe("getSunElevation", () => {
+  it("returns positive elevation at solar noon", () => {
+    // Tokyo solar noon ≈ 02:43 UTC on 2024-06-21
+    const date = new Date("2024-06-21T02:43:00Z");
+    expect(getSunElevation(date, 35.68, 139.69)).toBeGreaterThan(0);
+  });
+
+  it("returns negative elevation at solar midnight", () => {
+    // Tokyo solar midnight ≈ 14:43 UTC on 2024-06-21
+    const date = new Date("2024-06-21T14:43:00Z");
+    expect(getSunElevation(date, 35.68, 139.69)).toBeLessThan(0);
+  });
+});

package/src/solar.ts

@@ -0,0 +1,101 @@
+import {
+  AstroTime,
+  Body,
+  Equator,
+  Horizon,
+  HourAngle,
+  Observer,
+  SearchAltitude,
+  SearchHourAngle,
+} from "astronomy-engine";
+
+/**
+ * Returns the sun elevation angle in degrees at the given location and time.
+ * Includes atmospheric refraction correction.
+ */
+export function getSunElevation(date: Date, lat: number, lng: number): number {
+  const time = new AstroTime(date);
+  const observer = new Observer(lat, lng, 0);
+  const eq = Equator(Body.Sun, time, observer, true, true);
+  return Horizon(time, observer, eq.ra, eq.dec, "normal").altitude;
+}
+
+/**
+ * Returns a new Date such that the sun's hour angle at `targetLng` matches the
+ * hour angle currently at `fromLng`.
+ *
+ * Hour angle is longitude-dependent and increases monotonically 0→24 over a
+ * solar day, so there is exactly one solution per day — no morning/afternoon
+ * ambiguity.
+ */
+export function shiftDateToHourAngle(
+  date: Date,
+  fromLng: number,
+  targetLng: number,
+  targetLat = 0,
+): Date {
+  const time = new AstroTime(date);
+  const ha = HourAngle(Body.Sun, time, new Observer(0, fromLng, 0));
+  const dayStart = new AstroTime(
+    new Date(
+      Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
+    ),
+  );
+  return SearchHourAngle(
+    Body.Sun,
+    new Observer(targetLat, targetLng, 0),
+    ha,
+    dayStart,
+    1,
+  ).time.date;
+}
+
+/**
+ * Returns a new Date such that the sun elevation at `(targetLat, targetLng)`
+ * matches the elevation at `(fromLat, fromLng)` on the given date.
+ *
+ * Morning/afternoon context (rising vs setting) is inferred from the hour
+ * angle at `fromLng`. If the target elevation exceeds the maximum achievable
+ * at the location (e.g. polar night), the date is clamped to solar noon.
+ */
+export function shiftDateToElevation(
+  date: Date,
+  fromLat: number,
+  fromLng: number,
+  targetLat: number,
+  targetLng: number,
+): Date {
+  const targetAltitude = getSunElevation(date, fromLat, fromLng);
+
+  // HA > 12 means morning (0 = solar noon, 12 = solar midnight).
+  const isMorning =
+    HourAngle(Body.Sun, new AstroTime(date), new Observer(0, fromLng, 0)) > 12;
+
+  const observer = new Observer(targetLat, targetLng, 0);
+  const dayStart = new AstroTime(
+    new Date(
+      Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
+    ),
+  );
+
+  const noonTime = SearchHourAngle(Body.Sun, observer, 0, dayStart, 1).time;
+  const midnightTime = SearchHourAngle(
+    Body.Sun,
+    observer,
+    12,
+    new AstroTime(new Date(noonTime.date.getTime() - 13 * 3_600_000)),
+    1,
+  ).time;
+
+  const searchStart = isMorning ? midnightTime : noonTime;
+  const result = SearchAltitude(
+    Body.Sun,
+    observer,
+    isMorning ? 1 : -1,
+    searchStart,
+    0.6,
+    targetAltitude,
+  );
+
+  return result?.date ?? noonTime.date;
+}

package/src/source.ts

@@ -0,0 +1,80 @@
+import type { Core } from "@navaramap/engine";
+
+import type { SourceDescription } from "./type";
+
+/**
+ * A handle to a data source (GeoJSON, vector tile, raster tile, raster DEM,
+ * quantized mesh, 3D Tiles) registered via {@link ThreeView.addSource}.
+ *
+ * A source describes where data comes from and how it is fetched/decoded. One
+ * source can be referenced by multiple layers (by its `id`). The engine
+ * reference-counts sources and refuses to delete a source while any layer still
+ * references it.
+ *
+ * @example
+ * ```typescript
+ * const poi = view.addSource({
+ *   type: "vector-tile",
+ *   url: "https://example.com/{z}/{x}/{y}.pbf",
+ * });
+ *
+ * view.addLayer({
+ *   type: "vector",
+ *   source: poi,
+ *   sourceLayers: ["building"],
+ *   polygon: { color: 0x00aaff },
+ * });
+ * view.addLayer({
+ *   type: "vector",
+ *   source: poi,
+ *   sourceLayers: ["building"],
+ *   polyline: { color: 0xffffff },
+ * });
+ */
+export class Source {
+  /** The unique identifier of this source, used to reference it from layers. */
+  readonly id: string;
+  /** The discriminant type of this source (e.g. "vector-tile"). */
+  readonly type: string;
+  private core: Core;
+
+  constructor(id: string, type: string, core: Core) {
+    this.id = id;
+    this.type = type;
+    this.core = core;
+  }
+
+  /**
+   * Updates the source configuration and re-fetches its data. Every layer that
+   * references this source is reset (its resources are torn down) and reloaded
+   * against the new configuration.
+   *
+   * The update is partial, like {@link Layer.update}: any field you omit keeps
+   * its current value instead of resetting to a default. `type` cannot change
+   * and is always required; `url` is required by the type but, when set to the
+   * unchanged value, leaves the fetched URL as-is.
+   *
+   * @example
+   * ```typescript
+   * // Only maxZoom changes; tms and the other fields are preserved.
+   * imagery.update({
+   *   type: "raster-tile",
+   *   url: "https://example.com/{z}/{x}/{y}.png",
+   *   maxZoom: 22,
+   * });
+   * ```
+   */
+  update(s: SourceDescription) {
+    this.core.updateSource(this.id, s);
+  }
+
+  /**
+   * Removes the source and its resources.
+   *
+   * @returns `false` (and removes nothing) while any layer still references this
+   * source; `true` once the source has been removed.
+   */
+  delete(): boolean {
+    return this.core.deleteSource(this.id);
+  }
+}

package/src/stats.ts

@@ -0,0 +1,102 @@
+import Stats from "stats.js";
+
+type Renderer = {
+  beginRender: () => void;
+  endRender: () => {
+    calls?: number;
+    triangles?: number;
+    memGeometries?: number;
+  };
+};
+
+export type MemorySample = {
+  /** WASM BufferStore bytes (WASM-resident only), in MB. */
+  wasmMB?: number;
+  /** JS-side `InMemoryBufferStore` bytes (WASM `External` entries), in MB. */
+  jsBufMB?: number;
+  /** JS heap usage (Chrome-only `performance.memory`), in MB. */
+  jsHeapMB?: number;
+  /** Cache budget for the panel scale, in MB. */
+  budgetMB?: number;
+};
+
+/** How often the (relatively costly) memory sampler runs. */
+const MEMORY_SAMPLE_INTERVAL_MS = 1000;
+
+export class RendererStats {
+  stats: Stats;
+  renderer: Renderer;
+  drawCalls: Stats.Panel;
+  numTriangles: Stats.Panel;
+  memGeometries: Stats.Panel;
+  wasmMemory: Stats.Panel;
+  jsMemory: Stats.Panel;
+  private memorySampler?: () => MemorySample | undefined;
+  private lastMemorySampleAt = 0;
+  private maxWasmMB = 1;
+  private maxJsHeapMB = 1;
+  constructor(r: Renderer, memorySampler?: () => MemorySample | undefined) {
+    this.stats = new Stats();
+    this.renderer = r;
+    this.memorySampler = memorySampler;
+    this.drawCalls = this.stats.addPanel(
+      new Stats.Panel("Draws", "#0ff", "#002"),
+    );
+    this.numTriangles = this.stats.addPanel(
+      new Stats.Panel("Triangles", "#0fff57", "#013a12"),
+    );
+    this.memGeometries = this.stats.addPanel(
+      new Stats.Panel("Geometries", "#ffa100", "#301e00"),
+    );
+    this.wasmMemory = this.stats.addPanel(
+      new Stats.Panel("WASM MB", "#f08", "#201"),
+    );
+    this.jsMemory = this.stats.addPanel(
+      new Stats.Panel("JS MB", "#f4f", "#210"),
+    );
+    this.stats.showPanel(0);
+  }
+
+  begin() {
+    this.renderer.beginRender();
+    this.stats.begin();
+  }
+
+  end() {
+    const info = this.renderer.endRender();
+    if (info.calls) {
+      this.drawCalls.update(info.calls, 500);
+    }
+    if (info.triangles) {
+      this.numTriangles.update(info.triangles, 500);
+    }
+    if (info.memGeometries) {
+      this.memGeometries.update(info.memGeometries, 500);
+    }
+    this.sampleMemory();
+    this.stats.end();
+  }
+
+  /** Samples memory at most once per second to keep FFI out of the hot path. */
+  private sampleMemory() {
+    if (!this.memorySampler) return;
+    const now = performance.now();
+    if (now - this.lastMemorySampleAt < MEMORY_SAMPLE_INTERVAL_MS) return;
+    this.lastMemorySampleAt = now;
+
+    const sample = this.memorySampler();
+    if (!sample) return;
+    if (sample.wasmMB !== undefined) {
+      this.maxWasmMB = Math.max(this.maxWasmMB, sample.wasmMB);
+      this.wasmMemory.update(sample.wasmMB, sample.budgetMB ?? this.maxWasmMB);
+    }
+    if (sample.jsHeapMB !== undefined) {
+      this.maxJsHeapMB = Math.max(this.maxJsHeapMB, sample.jsHeapMB);
+      this.jsMemory.update(sample.jsHeapMB, this.maxJsHeapMB);
+    }
+  }
+
+  get dom() {
+    return this.stats.dom;
+  }
+}

package/src/tasks/computeVertexNormalsAsync.ts

@@ -0,0 +1,15 @@
+import { type BufferGeometry } from "three";
+
+import { fromBufferGeometryLike, toBufferGeometryLike } from "../utils";
+
+import { queueTask } from "./queueTask";
+
+export async function computeVertexNormalsAsync(
+  geometry: BufferGeometry,
+): Promise<BufferGeometry> {
+  const [geometryLike, transfer] = toBufferGeometryLike(geometry);
+  const result = await queueTask("computeVertexNormals", [geometryLike], {
+    transfer,
+  });
+  return fromBufferGeometryLike(result, geometry);
+}