@navaramap/three 0.0.0 → 0.0.2

package/src/utils/demNoDataColor.ts

@@ -0,0 +1,48 @@
+/**
+ * Solve `dot(rgb, scaler) == boundary` for RGB bytes: the color a DEM texel
+ * must hold so the shader's `decodeDEMHeight` classifies it as no-data. The
+ * raster bake paints a baked heatmap render target with this color before
+ * drawing sources, so uncovered regions decode as "no elevation here" —
+ * entirely inside the encoded-elevation domain, leaving the alpha channel
+ * untouched (it is not part of any encoding and stays reserved for future
+ * RGBA ones).
+ *
+ * Solved by greedy positional decomposition (largest scaler first), which is
+ * exact for the positional presets (GSI, Mapbox, Terrarium); a non-exact
+ * decomposition is still accepted when it lands inside the shader's no-data
+ * tolerance band (`decodeDEMHeight` flags |x − boundary| <= 1). Returns null
+ * only when no byte color decodes within that band (an exotic custom decoder
+ * whose encoding cannot express no-data at all) — callers then skip the
+ * no-data underlay and a baked target's uncovered regions decode as whatever
+ * black decodes to, which the shader may colormap as a valid height.
+ */
+export function demNoDataColorBytes(
+  scaler: { x: number; y: number; z: number },
+  boundary: number,
+): [number, number, number] | null {
+  const channels: { scaler: number; index: number }[] = [
+    { scaler: scaler.x, index: 0 },
+    { scaler: scaler.y, index: 1 },
+    { scaler: scaler.z, index: 2 },
+  ]
+    .filter((c) => c.scaler > 0)
+    .sort((a, b) => b.scaler - a.scaler);
+
+  const rgb: [number, number, number] = [0, 0, 0];
+  let rest = boundary;
+  for (const { scaler: s, index } of channels) {
+    // The epsilon guards float division just below an integer (e.g. 0.999…).
+    const v = Math.min(255, Math.max(0, Math.floor(rest / s + 1e-9)));
+    rgb[index] = v;
+    rest -= v * s;
+  }
+
+  // The shader flags |x - boundary| <= 1 as no-data (dem_util.glsl,
+  // `epsilon_cmp`): accept exactly that band, boundary included — a color a
+  // full 1 away still classifies as no-data, so rejecting it would skip the
+  // underlay and let uncovered baked regions decode black as a valid height.
+  // No safety margin is subtracted: painting a band-edge color that float32
+  // drift pushes out of the band decodes as a near-boundary height, which is
+  // no worse than the black the skipped underlay would leave behind.
+  return Math.abs(rest) <= 1 ? rgb : null;
+}

package/src/utils/fixedGpuFootprint.test.ts

@@ -0,0 +1,110 @@
+import type { EffectComposer, Pass } from "postprocessing";
+import { DepthTexture, HalfFloatType, WebGLRenderTarget } from "three";
+import { describe, expect, it } from "vitest";
+
+import { estimateFixedGpuBytes } from "./fixedGpuFootprint";
+
+const W = 100;
+const H = 10;
+const PX = W * H;
+
+function composerWith(
+  input: WebGLRenderTarget,
+  output: WebGLRenderTarget,
+): EffectComposer {
+  return { inputBuffer: input, outputBuffer: output } as EffectComposer;
+}
+
+function rgba8Target(): WebGLRenderTarget {
+  return new WebGLRenderTarget(W, H, { depthBuffer: false });
+}
+
+describe("estimateFixedGpuBytes", () => {
+  it("sums composer buffers by texture type and depth attachment", () => {
+    const input = new WebGLRenderTarget(W, H, {
+      type: HalfFloatType,
+      depthBuffer: true,
+    });
+    const output = new WebGLRenderTarget(W, H, { depthBuffer: false });
+    const bytes = estimateFixedGpuBytes(composerWith(input, output), []);
+    // input: RGBA16F (8) + depth (4); output: RGBA8 (4)
+    expect(bytes).toBe(PX * (8 + 4) + PX * 4);
+  });
+
+  it("counts a render target reachable from two passes only once", () => {
+    const shared = rgba8Target();
+    const passes = [
+      { renderTarget: shared } as unknown as Pass,
+      { anotherRef: shared } as unknown as Pass,
+    ];
+    const bytes = estimateFixedGpuBytes(
+      composerWith(rgba8Target(), rgba8Target()),
+      passes,
+    );
+    expect(bytes).toBe(PX * 4 * 3);
+  });
+
+  it("finds targets nested in pass properties and arrays", () => {
+    const nested = { copyPass: { target: rgba8Target() } } as unknown as Pass;
+    const inArray = {
+      effects: [{ renderTarget: rgba8Target() }],
+    } as unknown as Pass;
+    const bytes = estimateFixedGpuBytes(
+      composerWith(rgba8Target(), rgba8Target()),
+      [nested, inArray],
+    );
+    expect(bytes).toBe(PX * 4 * 4);
+  });
+
+  it("adds MSAA renderbuffer bytes on multisampled targets", () => {
+    const msaa = new WebGLRenderTarget(W, H, {
+      samples: 4,
+      depthBuffer: true,
+    });
+    const bytes = estimateFixedGpuBytes(composerWith(msaa, rgba8Target()), []);
+    // msaa: RGBA8 resolve (4) + depth (4) + 4 samples × (4 + 4); output: 4
+    expect(bytes).toBe(PX * (4 + 4 + 4 * 8) + PX * 4);
+  });
+
+  it("counts every MRT attachment and depth textures in the MSAA term", () => {
+    const mrt = new WebGLRenderTarget(W, H, {
+      count: 2,
+      samples: 2,
+      depthBuffer: false,
+    });
+    mrt.textures[1].type = HalfFloatType;
+    mrt.depthTexture = new DepthTexture(W, H);
+    const bytes = estimateFixedGpuBytes(composerWith(mrt, rgba8Target()), []);
+    // mrt: RGBA8 (4) + RGBA16F (8) + depth texture (4)
+    //      + 2 samples × (4 + 8 + 4); output: 4
+    expect(bytes).toBe(PX * (4 + 8 + 4 + 2 * 16) + PX * 4);
+  });
+
+  it("skips render targets that are not GL-allocated yet", () => {
+    const allocated = rgba8Target();
+    const lazy = rgba8Target();
+    const composer = {
+      inputBuffer: allocated,
+      outputBuffer: lazy,
+      getRenderer: () => ({
+        properties: {
+          get: (object: object) =>
+            object === allocated ? { __webglFramebuffer: {} } : {},
+        },
+      }),
+    } as unknown as EffectComposer;
+    expect(estimateFixedGpuBytes(composer, [])).toBe(PX * 4);
+  });
+
+  it("does not walk into typed arrays or huge buffers", () => {
+    const pass = {
+      geometryData: new Float32Array(1_000_000),
+      target: rgba8Target(),
+    } as unknown as Pass;
+    const bytes = estimateFixedGpuBytes(
+      composerWith(rgba8Target(), rgba8Target()),
+      [pass],
+    );
+    expect(bytes).toBe(PX * 4 * 3);
+  });
+});

package/src/utils/fixedGpuFootprint.ts

@@ -0,0 +1,162 @@
+import type { EffectComposer, Pass } from "postprocessing";
+import {
+  FloatType,
+  HalfFloatType,
+  Material,
+  Object3D,
+  Texture,
+  WebGLRenderTarget,
+} from "three";
+
+const DEPTH_BYTES_PER_TEXEL = 4; // DEPTH24_STENCIL8 / DEPTH_COMPONENT32F
+const MIPMAP_FACTOR = 1.33;
+
+function bytesPerTexel(type: number): number {
+  switch (type) {
+    case FloatType:
+      return 16; // RGBA32F
+    case HalfFloatType:
+      return 8; // RGBA16F
+    default:
+      return 4; // RGBA8 and friends
+  }
+}
+
+function renderTargetBytes(target: WebGLRenderTarget): number {
+  const pixels = target.width * target.height;
+  let bytes = 0;
+  for (const texture of target.textures) {
+    let textureBytes = pixels * bytesPerTexel(texture.type);
+    if (texture.generateMipmaps) {
+      textureBytes = Math.floor(textureBytes * MIPMAP_FACTOR);
+    }
+    bytes += textureBytes;
+  }
+  if (target.depthBuffer || target.depthTexture) {
+    bytes += pixels * DEPTH_BYTES_PER_TEXEL;
+  }
+  if (target.samples > 0) {
+    // MSAA renderbuffers exist alongside the resolve textures: one per color
+    // attachment, plus a depth renderbuffer whether depth is a plain buffer
+    // or a depth texture.
+    let msaaBytesPerPixel = 0;
+    for (const texture of target.textures) {
+      msaaBytesPerPixel += bytesPerTexel(texture.type);
+    }
+    if (target.depthBuffer || target.depthTexture) {
+      msaaBytesPerPixel += DEPTH_BYTES_PER_TEXEL;
+    }
+    bytes += target.samples * pixels * msaaBytesPerPixel;
+  }
+  return bytes;
+}
+
+function collectRenderTargets(
+  value: unknown,
+  targets: Set<WebGLRenderTarget>,
+  visited: Set<object>,
+  depth: number,
+): void {
+  if (value === null || typeof value !== "object" || visited.has(value)) {
+    return;
+  }
+  visited.add(value);
+
+  if (value instanceof WebGLRenderTarget) {
+    targets.add(value);
+    return;
+  }
+
+  // Prune subtrees that cannot contain render targets: scene graphs,
+  // materials, textures, and raw buffers (Object.keys on a large typed array
+  // would enumerate every element).
+  if (
+    depth <= 0 ||
+    ArrayBuffer.isView(value) ||
+    value instanceof ArrayBuffer ||
+    value instanceof Object3D ||
+    value instanceof Material ||
+    value instanceof Texture
+  ) {
+    return;
+  }
+
+  // Shallow property scan, mirroring postprocessing's Pass.dispose() search.
+  // Recursion is bounded so nested passes/effects (e.g. CustomRenderPass's
+  // copy passes, EffectPass's effects) are covered without walking the scene.
+  for (const key of Object.keys(value)) {
+    const child = (value as Record<string, unknown>)[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        collectRenderTargets(item, targets, visited, depth - 1);
+      }
+    } else {
+      collectRenderTargets(child, targets, visited, depth - 1);
+    }
+  }
+}
+
+/**
+ * Returns whether the render target has actually been allocated on the GPU.
+ * Three.js allocates lazily on first `setRenderTarget`, so targets that a
+ * pipeline never renders into (e.g. a `CopyPass` used with `renderToScreen`,
+ * the composer's output buffer while no pass swaps, mode-dependent merge
+ * targets) hold no GPU memory and must not be charged to the ledger.
+ * `renderer.properties` is an internal-but-stable API (postprocessing itself
+ * relies on it); when it is unavailable, assume allocated.
+ */
+function isAllocated(renderer: unknown, target: WebGLRenderTarget): boolean {
+  const properties = (
+    renderer as {
+      properties?: { get(object: object): { __webglFramebuffer?: unknown } };
+    } | null
+  )?.properties;
+  if (!properties) return true;
+  return properties.get(target).__webglFramebuffer !== undefined;
+}
+
+/**
+ * Estimates the resident GPU bytes of the fixed (screen-sized, non-tile)
+ * render-target stack: the composer's ping-pong and depth buffers plus every
+ * render target reachable from the registered passes and their effects.
+ * Targets not yet allocated on the GPU are skipped, so the estimate should be
+ * re-taken after rendering (allocations happen lazily during the first frames
+ * that exercise a code path).
+ *
+ * The result is an estimate in the same accuracy class as the ledger's
+ * `gpu_bytes_est`: texture formats are mapped to nominal byte sizes and
+ * driver padding is ignored.
+ */
+export function estimateFixedGpuBytes(
+  composer: EffectComposer,
+  passes: Iterable<Pass>,
+): number {
+  const targets = new Set<WebGLRenderTarget>();
+  const visited = new Set<object>();
+
+  collectRenderTargets(composer.inputBuffer, targets, visited, 0);
+  collectRenderTargets(composer.outputBuffer, targets, visited, 0);
+  // Stable-depth target (postprocessing >= 6.39); private, hence the cast.
+  collectRenderTargets(
+    (composer as unknown as { depthRenderTarget?: WebGLRenderTarget | null })
+      .depthRenderTarget,
+    targets,
+    visited,
+    0,
+  );
+
+  for (const pass of passes) {
+    collectRenderTargets(pass, targets, visited, 3);
+  }
+
+  const renderer = (
+    composer as unknown as { getRenderer?: () => unknown }
+  ).getRenderer?.();
+
+  let bytes = 0;
+  for (const target of targets) {
+    if (!isAllocated(renderer, target)) continue;
+    bytes += renderTargetBytes(target);
+  }
+  return bytes;
+}

package/src/worker/tasks/toCreasedNormals.ts

@@ -1,15 +1,10 @@
 // Ref: https://github.com/takram-design-engineering/geovanni/blob/ee91f675ba2558ee3099f635dfa30bbe3adfe103/libs/3d-tiles/src/toCreasedNormalsAsync.ts
 
-/* eslint-env worker */
-
 import { transfer } from "@navaramap/worker";
 import { toCreasedNormals as toCreasedNormalsImpl } from "three-stdlib";
 
-import {
-  fromBufferGeometryLike,
-  toBufferGeometryLike,
-  type BufferGeometryLike,
-} from "../../utils";
+import { fromBufferGeometryLike, toBufferGeometryLike } from "../../utils";
+import type { BufferGeometryLike } from "../../utils";
 
 export function toCreasedNormals(
   input: BufferGeometryLike,