@navaramap/three 0.0.4 → 0.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@navaramap/three",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "main": "dist/index.umd.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,13 +30,13 @@
     "astronomy-engine": "2.1.19",
     "stats.js": "0.17.0",
     "three-stdlib": "2.36.1",
-    "@navaramap/core": "0.0.4",
-    "@navaramap/engine": "0.0.4",
-    "@navaramap/engine-api": "0.0.4",
-    "@navaramap/three-api": "0.0.4",
-    "@navaramap/three-csm": "0.0.4",
-    "@navaramap/font": "0.0.4",
-    "@navaramap/worker": "0.0.4"
+    "@navaramap/core": "0.0.5",
+    "@navaramap/engine": "0.0.5",
+    "@navaramap/engine-api": "0.0.5",
+    "@navaramap/font": "0.0.5",
+    "@navaramap/three-api": "0.0.5",
+    "@navaramap/three-csm": "0.0.5",
+    "@navaramap/worker": "0.0.5"
   },
   "devDependencies": {
     "@playwright/test": "1.61.1",
@@ -71,10 +71,10 @@
     "tweakpane": "4.0.5",
     "vite-plugin-glsl": "1.6.0",
     "vite-plugin-static-copy": "4.1.1",
-    "@navaramap/three-default-descs": "0.0.4",
-    "@navaramap/three-plugins": "0.0.4",
-    "@navaramap/three-default-plugin": "0.0.4",
-    "@navaramap/three-react": "0.0.4"
+    "@navaramap/three-default-descs": "0.0.5",
+    "@navaramap/three-plugins": "0.0.5",
+    "@navaramap/three-react": "0.0.5",
+    "@navaramap/three-default-plugin": "0.0.5"
   },
   "scripts": {
     "start": "vite",

package/src/atmosphere.test.ts

@@ -1,76 +1,275 @@
-import type { WebGLRenderer } from "three";
+import { type WebGLRenderer } from "three";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { Atmosphere } from "./atmosphere";
+import { Atmosphere, type AtmosphereOptions } from "./atmosphere";
 
 const { loadAsyncMock } = vi.hoisted(() => ({
   loadAsyncMock: vi.fn(),
 }));
 
 vi.mock("@takram/three-atmosphere", () => ({
-  PrecomputedTexturesLoader: class {
-    setType() {
-      return this;
-    }
-    loadAsync = loadAsyncMock;
-  },
   getSunDirectionECEF: vi.fn(),
   getMoonDirectionECEF: vi.fn(),
   getECIToECEFRotationMatrix: vi.fn(),
+  TRANSMITTANCE_TEXTURE_WIDTH: 256,
+  TRANSMITTANCE_TEXTURE_HEIGHT: 64,
+  IRRADIANCE_TEXTURE_WIDTH: 64,
+  IRRADIANCE_TEXTURE_HEIGHT: 16,
+  SCATTERING_TEXTURE_WIDTH: 256,
+  SCATTERING_TEXTURE_HEIGHT: 128,
+  SCATTERING_TEXTURE_DEPTH: 32,
 }));
 
-const createAtmosphere = () =>
-  new Atmosphere({} as unknown as WebGLRenderer, { date: new Date(0) });
+vi.mock("@takram/three-geospatial", () => {
+  class MockLoader {
+    loadAsync = loadAsyncMock;
+  }
+  return {
+    EXRTextureLoader: MockLoader,
+    EXR3DTextureLoader: MockLoader,
+    isFloatLinearSupported: () => false,
+    reinterpretType: () => {},
+  };
+});
+
+const fakeTexture = () => ({ image: {}, dispose: vi.fn() });
+
+/** Resolves every load immediately with a fake texture, recording the URL. */
+const autoResolveLoads = () => {
+  loadAsyncMock.mockImplementation(() => Promise.resolve(fakeTexture()));
+};
+
+const requestedFiles = () =>
+  loadAsyncMock.mock.calls.map((call) => {
+    const url = call[0] as string;
+    return url.slice(url.lastIndexOf("/") + 1).replace(/\?.*$/, "");
+  });
+
+const createAtmosphere = (options?: Partial<AtmosphereOptions>) =>
+  new Atmosphere({} as unknown as WebGLRenderer, {
+    date: new Date(0),
+    ...options,
+  });
 
-const fakeTextures = () => ({}) as never;
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
 
 describe("Atmosphere.initTextures", () => {
   beforeEach(() => {
     loadAsyncMock.mockReset();
   });
 
-  it("shares a single load across concurrent calls", async () => {
-    loadAsyncMock.mockResolvedValue(fakeTextures());
+  it("loads all four textures", async () => {
+    autoResolveLoads();
+    const atmosphere = createAtmosphere();
+
+    await atmosphere.initTextures();
+
+    expect(requestedFiles().sort()).toEqual([
+      "higher_order_scattering.exr",
+      "irradiance.exr",
+      "scattering.exr",
+      "transmittance.exr",
+    ]);
+    expect(atmosphere.textures.transmittanceTexture).toBeDefined();
+    expect(atmosphere.textures.scatteringTexture).toBeDefined();
+    expect(atmosphere.textures.irradianceTexture).toBeDefined();
+    expect(atmosphere.textures.higherOrderScatteringTexture).toBeDefined();
+  });
+
+  it("shares in-flight loads across concurrent calls", async () => {
+    autoResolveLoads();
     const atmosphere = createAtmosphere();
 
     await Promise.all([atmosphere.initTextures(), atmosphere.initTextures()]);
 
-    expect(loadAsyncMock).toHaveBeenCalledTimes(1);
-    expect(atmosphere.textures).toBeDefined();
+    expect(loadAsyncMock).toHaveBeenCalledTimes(4);
   });
 
-  it("returns immediately once textures are loaded", async () => {
-    loadAsyncMock.mockResolvedValue(fakeTextures());
+  it("does not reload once textures are loaded", async () => {
+    autoResolveLoads();
     const atmosphere = createAtmosphere();
 
     await atmosphere.initTextures();
     await atmosphere.initTextures();
 
-    expect(loadAsyncMock).toHaveBeenCalledTimes(1);
+    expect(loadAsyncMock).toHaveBeenCalledTimes(4);
   });
 
-  it("emits textureLoaded exactly once", async () => {
-    loadAsyncMock.mockResolvedValue(fakeTextures());
+  it("emits textureLoaded once per texture", async () => {
+    autoResolveLoads();
     const atmosphere = createAtmosphere();
     const onLoaded = vi.fn();
     atmosphere.on("textureLoaded", onLoaded);
 
-    await Promise.all([atmosphere.initTextures(), atmosphere.initTextures()]);
+    await atmosphere.initTextures();
 
-    expect(onLoaded).toHaveBeenCalledTimes(1);
+    expect(onLoaded).toHaveBeenCalledTimes(4);
   });
 
-  it("allows retrying after a failed load", async () => {
-    loadAsyncMock.mockRejectedValueOnce(new Error("network error"));
-    loadAsyncMock.mockResolvedValueOnce(fakeTextures());
+  it("retries only the texture that failed", async () => {
+    let failTransmittance = true;
+    loadAsyncMock.mockImplementation((url: string) => {
+      if (failTransmittance && url.includes("transmittance.exr")) {
+        return Promise.reject(new Error("network error"));
+      }
+      return Promise.resolve(fakeTexture());
+    });
     const atmosphere = createAtmosphere();
 
     await expect(atmosphere.initTextures()).rejects.toThrow("network error");
-    expect(atmosphere.textures).toBeUndefined();
+    expect(atmosphere.textures.transmittanceTexture).toBeUndefined();
+    expect(atmosphere.textures.scatteringTexture).toBeDefined();
 
+    failTransmittance = false;
     await atmosphere.initTextures();
 
-    expect(loadAsyncMock).toHaveBeenCalledTimes(2);
-    expect(atmosphere.textures).toBeDefined();
+    expect(atmosphere.textures.transmittanceTexture).toBeDefined();
+    expect(
+      requestedFiles().filter((f) => f === "transmittance.exr"),
+    ).toHaveLength(2);
+    expect(requestedFiles().filter((f) => f === "scattering.exr")).toHaveLength(
+      1,
+    );
+  });
+
+  it("loads from atmosphereAssetsUrl when provided, normalizing slashes", async () => {
+    autoResolveLoads();
+    const atmosphere = createAtmosphere({
+      atmosphereAssetsUrl: "https://example.com/assets/",
+    });
+
+    await atmosphere.initTextures();
+
+    for (const [url] of loadAsyncMock.mock.calls as [string][]) {
+      expect(url).toMatch(/^https:\/\/example\.com\/assets\/[a-z_]+\.exr$/);
+    }
+  });
+});
+
+describe("Atmosphere.onTexturesReady", () => {
+  beforeEach(() => {
+    loadAsyncMock.mockReset();
+  });
+
+  it("does not load anything until a consumer registers", () => {
+    autoResolveLoads();
+    createAtmosphere();
+
+    expect(loadAsyncMock).not.toHaveBeenCalled();
+  });
+
+  it("loads only the needed textures", async () => {
+    autoResolveLoads();
+    const atmosphere = createAtmosphere();
+    const callback = vi.fn();
+
+    atmosphere.onTexturesReady(callback, { transmittance: true });
+    await flush();
+
+    expect(requestedFiles()).toEqual(["transmittance.exr"]);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback.mock.calls[0][0].transmittanceTexture).toBeDefined();
+  });
+
+  it("shares a fetch between consumers needing the same texture", async () => {
+    autoResolveLoads();
+    const atmosphere = createAtmosphere();
+    const first = vi.fn();
+    const second = vi.fn();
+
+    atmosphere.onTexturesReady(first, { transmittance: true });
+    atmosphere.onTexturesReady(second, { transmittance: true });
+    await flush();
+
+    expect(loadAsyncMock).toHaveBeenCalledTimes(1);
+    expect(first).toHaveBeenCalledTimes(1);
+    expect(second).toHaveBeenCalledTimes(1);
+  });
+
+  it("fetches only the missing textures for wider needs", async () => {
+    autoResolveLoads();
+    const atmosphere = createAtmosphere();
+
+    atmosphere.onTexturesReady(vi.fn(), { transmittance: true });
+    await flush();
+    const callback = vi.fn();
+    atmosphere.onTexturesReady(callback, {
+      transmittance: true,
+      scattering: true,
+    });
+    await flush();
+
+    expect(requestedFiles()).toEqual(["transmittance.exr", "scattering.exr"]);
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("loads all textures and fires once when needs are omitted", async () => {
+    autoResolveLoads();
+    const atmosphere = createAtmosphere();
+    const callback = vi.fn();
+
+    atmosphere.onTexturesReady(callback);
+    await flush();
+
+    expect(loadAsyncMock).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("waits until every needed texture is ready", async () => {
+    const pending = new Map<string, (t: unknown) => void>();
+    loadAsyncMock.mockImplementation(
+      (url: string) =>
+        new Promise((resolve) => {
+          pending.set(
+            url.slice(url.lastIndexOf("/") + 1).replace(/\?.*$/, ""),
+            resolve,
+          );
+        }),
+    );
+    const atmosphere = createAtmosphere();
+    const callback = vi.fn();
+
+    atmosphere.onTexturesReady(callback, {
+      transmittance: true,
+      scattering: true,
+    });
+    pending.get("transmittance.exr")?.(fakeTexture());
+    await flush();
+    expect(callback).not.toHaveBeenCalled();
+
+    pending.get("scattering.exr")?.(fakeTexture());
+    await flush();
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("invokes the callback immediately once loaded", async () => {
+    autoResolveLoads();
+    const atmosphere = createAtmosphere();
+    await atmosphere.initTextures();
+    const callback = vi.fn();
+
+    atmosphere.onTexturesReady(callback, { irradiance: true });
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(loadAsyncMock).toHaveBeenCalledTimes(4);
+  });
+
+  it("logs instead of rejecting when a lazy load fails", async () => {
+    const error = new Error("network error");
+    loadAsyncMock.mockRejectedValue(error);
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const atmosphere = createAtmosphere();
+
+    atmosphere.onTexturesReady(vi.fn(), { transmittance: true });
+
+    await vi.waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith(
+        "Failed to load atmosphere textures:",
+        error,
+      );
+    });
+    consoleError.mockRestore();
   });
 });