@es3d/es3d 1.1.2 → 1.2.1

package/src/render/frame-builder.js

@@ -171,23 +171,31 @@ export class FrameBuilder {
    */
   build(p) {
     const { scene, camera, pool, meshOf, options } = p;
-    const n = scene.count;
+    // A SceneSet draws several instance tables (the host and the fragments,
+    // scene-set.js); a RenderScene is one part whose indices need no map.
+    const parts = scene.parts ? scene.drawnParts() : [{ scene, geomMap: null, matMap: null, selectable: true }];
+    let n = 0;
+    for (const part of parts) n += part.scene.count;
     // reserve instance rows for: batches (<= n), bounding boxes (<= n), selection boxes
     let selCount = 0;
     if (options.selection && options.selection.size) {
-      for (let i = 0; i < n; i++) if (options.selection.has(scene.uid[i])) selCount++;
+      for (const part of parts) {
+        if (!part.selectable) continue;
+        const P = part.scene;
+        for (let i = 0; i < P.count; i++) if (options.selection.has(P.uid[i])) selCount++;
+      }
     }
     this.ensure(n + (options.bbox ? n : 0) + selCount + 64);
     const camPos = camera.position;
     const dist = (c) => Math.hypot(c[0] - camPos[0], c[1] - camPos[1], c[2] - camPos[2]);
-    const sw = this.lodStates(scene, camPos, dist);
     const planes = options.culling === false ? null : planesFrom(camera.viewProj);
-    const S = scene.spheres;
     const keys = this.keys;
     const lods = this.lods;
     const batchMap = new Map();
     const batches = [];
-    const nMat = Math.max(1, scene.materials.length);
+    const geometries = scene.geometries;
+    const materials = scene.materials;
+    const nMat = Math.max(1, materials.length);
     const lodHist = [0, 0, 0, 0];
     let visibleCount = 0;
     let culled = 0;
@@ -197,52 +205,64 @@ export class FrameBuilder {
     // pixels per world unit: depth based for perspective, constant for orthographic
     const lodK = lodFrameConstants(camera, vh);
 
-    for (let i = 0; i < n; i++) {
-      keys[i] = -1;
-      const ln = scene.lodNode[i];
-      if (ln >= 0 && !(sw.visible[ln] && sw.active[ln] === scene.lodChild[i])) continue;
-      const cx = S[i * 4], cy = S[i * 4 + 1], cz = S[i * 4 + 2], r = S[i * 4 + 3];
-      if (planes) {
-        let out = false;
-        for (let k = 0; k < 5; k++) {
-          const pl = planes[k];
-          if (pl[0] * cx + pl[1] * cy + pl[2] * cz + pl[3] < -r) {
-            out = true;
-            break;
+    // rows are numbered across the parts: part k's row r is base(k) + r
+    let base = 0;
+    for (const part of parts) {
+      const P = part.scene;
+      const gm = part.geomMap;
+      const mm = part.matMap;
+      const pn = P.count;
+      const sw = this.lodStates(P, camPos, dist);
+      const S = P.spheres;
+      for (let r = 0; r < pn; r++) {
+        const i = base + r;
+        keys[i] = -1;
+        const ln = P.lodNode[r];
+        if (ln >= 0 && !(sw.visible[ln] && sw.active[ln] === P.lodChild[r])) continue;
+        const cx = S[r * 4], cy = S[r * 4 + 1], cz = S[r * 4 + 2], rad = S[r * 4 + 3];
+        if (planes) {
+          let out = false;
+          for (let k = 0; k < 5; k++) {
+            const pl = planes[k];
+            if (pl[0] * cx + pl[1] * cy + pl[2] * cz + pl[3] < -rad) {
+              out = true;
+              break;
+            }
+          }
+          if (out) {
+            culled++;
+            continue;
           }
         }
-        if (out) {
-          culled++;
-          continue;
+        const gi = gm ? gm[P.geom[r]] : P.geom[r];
+        const entry = geometries[gi];
+        let lod = 0;
+        if (entry.lods > 1) {
+          if (fixedLod >= 0) lod = Math.min(fixedLod, entry.lods - 1);
+          else {
+            const dx = cx - camPos[0], dy = cy - camPos[1], dz = cz - camPos[2];
+            const d = length3(dx, dy, dz);
+            const ppu = instancePixelsPerUnit(lodK, cx, cy, cz, d);
+            lod = selectLod(entry.lodDeviation, entry.lods, axisScale(P.matrices, r), ppu, bias);
+          }
         }
-      }
-      const gi = scene.geom[i];
-      const entry = scene.geometries[gi];
-      let lod = 0;
-      if (entry.lods > 1) {
-        if (fixedLod >= 0) lod = Math.min(fixedLod, entry.lods - 1);
-        else {
-          const dx = cx - camPos[0], dy = cy - camPos[1], dz = cz - camPos[2];
-          const d = length3(dx, dy, dz);
-          const ppu = instancePixelsPerUnit(lodK, cx, cy, cz, d);
-          lod = selectLod(entry.lodDeviation, entry.lods, axisScale(scene.matrices, i), ppu, bias);
+        lods[i] = lod;
+        lodHist[lod]++;
+        const mirrored = P.flags[r] & 1;
+        const mi = mm ? mm[P.mat[r]] : P.mat[r];
+        const key = ((gi * 4 + lod) * nMat + mi) * 2 + mirrored;
+        let b = batchMap.get(key);
+        if (b === undefined) {
+          b = batches.length;
+          batchMap.set(key, b);
+          const material = materials[mi];
+          batches.push({ gi, entry, lod, mi, material, mirrored: !!mirrored, count: 0, firstInstance: 0, depth: 0, instances: null });
         }
+        batches[b].count++;
+        keys[i] = b;
+        visibleCount++;
       }
-      lods[i] = lod;
-      lodHist[lod]++;
-      const mirrored = scene.flags[i] & 1;
-      const mi = scene.mat[i];
-      const key = ((gi * 4 + lod) * nMat + mi) * 2 + mirrored;
-      let b = batchMap.get(key);
-      if (b === undefined) {
-        b = batches.length;
-        batchMap.set(key, b);
-        const material = scene.materials[mi];
-        batches.push({ gi, entry, lod, mi, material, mirrored: !!mirrored, count: 0, firstInstance: 0, depth: 0, instances: null });
-      }
-      batches[b].count++;
-      keys[i] = b;
-      visibleCount++;
+      base += pn;
     }
 
     // resolve meshes / pool ranges. Once this frame has spent its tessellation
@@ -288,27 +308,32 @@ export class FrameBuilder {
       b.cursor = b.firstInstance;
     }
     const data = this.instanceData;
-    const M = scene.matrices;
-    const transparentInstances = [];
-    for (let i = 0; i < n; i++) {
-      const k = keys[i];
-      if (k < 0) continue;
-      const b = batches[k];
-      if (b.transparent) {
-        transparentInstances.push(i);
-        continue;
+    const transparent = []; // {M, r, b, depth}: drawn back to front after the opaque rows
+    base = 0;
+    for (const part of parts) {
+      const P = part.scene;
+      const M = P.matrices;
+      const S = P.spheres;
+      for (let r = 0; r < P.count; r++) {
+        const k = keys[base + r];
+        if (k < 0) continue;
+        const b = batches[k];
+        if (b.transparent) {
+          transparent.push({ M, r, b, depth: -length3(S[r * 4] - camPos[0], S[r * 4 + 1] - camPos[1], S[r * 4 + 2] - camPos[2]) });
+          continue;
+        }
+        const o = b.cursor++ * 16;
+        for (let j = 0; j < 16; j++) data[o + j] = M[r * 16 + j];
       }
-      const o = b.cursor++ * 16;
-      for (let j = 0; j < 16; j++) data[o + j] = M[i * 16 + j];
+      base += P.count;
     }
-    if (transparentInstances.length) {
-      const depthOf = (i) => -length3(S[i * 4] - camPos[0], S[i * 4 + 1] - camPos[1], S[i * 4 + 2] - camPos[2]);
-      transparentInstances.sort((a, b) => depthOf(a) - depthOf(b));
-      for (const i of transparentInstances) {
-        const b = batches[keys[i]];
+    if (transparent.length) {
+      transparent.sort((a, b) => a.depth - b.depth);
+      for (const t of transparent) {
+        const b = t.b;
         const o = b.cursor++ * 16;
-        for (let j = 0; j < 16; j++) data[o + j] = M[i * 16 + j];
-        b.depth = Math.max(b.depth, -depthOf(i));
+        for (let j = 0; j < 16; j++) data[o + j] = t.M[t.r * 16 + j];
+        b.depth = Math.max(b.depth, -t.depth);
       }
       // farthest transparent batches first
       const opaque = order.filter((b) => !b.transparent);
@@ -326,12 +351,13 @@ export class FrameBuilder {
         if (options.normals) overlays.normals.push({ range: pool.normalRange(b.mesh), firstInstance: b.firstInstance, count: b.count });
       }
     }
-    const boxMatrix = (i, o) => {
-      const e = scene.geometries[scene.geom[i]];
+    const boxMatrix = (part, r, o) => {
+      const P = part.scene;
+      const e = geometries[part.geomMap ? part.geomMap[P.geom[r]] : P.geom[r]];
       const bb = e.bounds;
       const cx = (bb.min[0] + bb.max[0]) / 2, cy = (bb.min[1] + bb.max[1]) / 2, cz = (bb.min[2] + bb.max[2]) / 2;
       const sx = Math.max(bb.max[0] - bb.min[0], 1e-4), sy = Math.max(bb.max[1] - bb.min[1], 1e-4), sz = Math.max(bb.max[2] - bb.min[2], 1e-4);
-      const m = M.subarray(i * 16, i * 16 + 16);
+      const m = P.matrices.subarray(r * 16, r * 16 + 16);
       // world * T(c) * S(s)
       for (let k = 0; k < 3; k++) {
         data[o + k] = m[k] * sx;
@@ -346,22 +372,33 @@ export class FrameBuilder {
     };
     if (options.bbox) {
       const first = offset;
-      for (let i = 0; i < n; i++) {
-        if (keys[i] < 0) continue;
-        boxMatrix(i, offset * 16);
-        offset++;
+      base = 0;
+      for (const part of parts) {
+        for (let r = 0; r < part.scene.count; r++) {
+          if (keys[base + r] < 0) continue;
+          boxMatrix(part, r, offset * 16);
+          offset++;
+        }
+        base += part.scene.count;
       }
       overlays.bbox = { firstInstance: first, count: offset - first };
     }
     if (selCount) {
       const first = offset;
       const sel = options.selection;
-      for (let i = 0; i < n; i++) {
-        if (!sel.has(scene.uid[i])) continue;
-        // hidden level-of-detail alternatives are not highlighted
-        if (keys[i] < 0 && scene.lodNode[i] >= 0) continue;
-        boxMatrix(i, offset * 16);
-        offset++;
+      base = 0;
+      for (const part of parts) {
+        const P = part.scene;
+        if (part.selectable) {
+          for (let r = 0; r < P.count; r++) {
+            if (!sel.has(P.uid[r])) continue;
+            // hidden level-of-detail alternatives are not highlighted
+            if (keys[base + r] < 0 && P.lodNode[r] >= 0) continue;
+            boxMatrix(part, r, offset * 16);
+            offset++;
+          }
+        }
+        base += P.count;
       }
       overlays.selection = { firstInstance: first, count: offset - first };
     }

package/src/render/geometry-pool.js

@@ -7,26 +7,93 @@
 // vertex. That keeps the WebGL2 and WebGPU paths the same.
 //
 // The pool is CPU-side; backends upload the ranges appended since their last
-// sync (or everything after a reallocation).
+// sync. The CPU copy is kept so a lost GPU context can be rebuilt.
+//
+// Growing and resetting are different events:
+// - Growing keeps every byte and adds room. The CPU side adds a chunk (old
+//   chunks are never copied), and backends grow their buffers with a GPU-side
+//   copy of what they already hold, then upload only what is new. Vertex and
+//   index storage grow independently.
+// - Resetting (reset(), a repack) throws the content away. It bumps
+//   `generation`, and backends reallocate and upload from zero.
 
 export const VERTEX_FLOATS = 8; // position xyz, normal xyz, uv
 export const VERTEX_BYTES = VERTEX_FLOATS * 4;
 
+/**
+ * A growable typed array stored as chunks. Element `i` of the whole array is
+ * in the chunk whose `start <= i < start + length`. Growing appends a chunk
+ * and never moves existing data.
+ */
+class ChunkedArray {
+  constructor(Type, stride, capacity) {
+    this.Type = Type;
+    this.stride = stride; // array entries per element (8 floats per vertex, 1 per index)
+    this.chunks = [{ start: 0, length: capacity, data: new Type(capacity * stride) }];
+    this.capacity = capacity; // elements
+  }
+
+  /** Make room for `count` elements in total. Returns true when it grew. */
+  reserve(count) {
+    if (count <= this.capacity) return false;
+    let cap = Math.max(1, this.capacity); // a zero capacity would never double
+    while (cap < count) cap *= 2;
+    const length = cap - this.capacity;
+    this.chunks.push({ start: this.capacity, length, data: new this.Type(length * this.stride) });
+    this.capacity = cap;
+    return true;
+  }
+
+  /**
+   * Visit the parts of elements [start, end) chunk by chunk:
+   * fn(firstElement, view), where view is the chunk's typed array restricted
+   * to that part.
+   */
+  forEach(start, end, fn) {
+    const s = this.stride;
+    for (const c of this.chunks) {
+      const a = Math.max(start, c.start);
+      const b = Math.min(end, c.start + c.length);
+      if (a < b) fn(a, c.data.subarray((a - c.start) * s, (b - c.start) * s));
+    }
+  }
+}
+
 export class GeometryPool {
   constructor(vertexCapacity = 1 << 16, indexCapacity = 1 << 17) {
-    this.vertices = new Float32Array(vertexCapacity * VERTEX_FLOATS);
-    this.indices = new Uint32Array(indexCapacity);
+    this.vertexStore = new ChunkedArray(Float32Array, VERTEX_FLOATS, vertexCapacity);
+    this.indexStore = new ChunkedArray(Uint32Array, 1, indexCapacity);
     this.vertexCount = 0;
     this.indexCount = 0;
     this.ranges = new Map(); // key object -> {firstIndex, indexCount}
     this.edgeRanges = new Map();
     this.normalRanges = new Map();
     // dirty tracking for incremental uploads
-    this.generation = 0; // bumps on reallocation
+    this.generation = 0; // bumps when the content is thrown away (reset, repack); NOT on growth
     this.uploadedVertices = 0;
     this.uploadedIndices = 0;
   }
 
+  /** Vertex capacity in vertices. Backends size their vertex buffer to at least this. */
+  get vertexCapacity() {
+    return this.vertexStore.capacity;
+  }
+
+  /** Index capacity in indices. */
+  get indexCapacity() {
+    return this.indexStore.capacity;
+  }
+
+  /** Capacity in bytes of the vertex storage. */
+  get vertexCapacityBytes() {
+    return this.vertexStore.capacity * VERTEX_BYTES;
+  }
+
+  /** Capacity in bytes of the index storage. */
+  get indexCapacityBytes() {
+    return this.indexStore.capacity * 4;
+  }
+
   reset() {
     this.vertexCount = 0;
     this.indexCount = 0;
@@ -42,60 +109,55 @@ export class GeometryPool {
     return this.vertexCount * VERTEX_BYTES + this.indexCount * 4;
   }
 
+  /** Make room for more vertices and indices. Growing keeps what is stored and uploaded. */
   ensure(extraV, extraI) {
-    let grew = false;
-    if ((this.vertexCount + extraV) * VERTEX_FLOATS > this.vertices.length) {
-      let cap = this.vertices.length / VERTEX_FLOATS;
-      while (cap < this.vertexCount + extraV) cap *= 2;
-      const v = new Float32Array(cap * VERTEX_FLOATS);
-      v.set(this.vertices.subarray(0, this.vertexCount * VERTEX_FLOATS));
-      this.vertices = v;
-      grew = true;
-    }
-    if (this.indexCount + extraI > this.indices.length) {
-      let cap = this.indices.length;
-      while (cap < this.indexCount + extraI) cap *= 2;
-      const i = new Uint32Array(cap);
-      i.set(this.indices.subarray(0, this.indexCount));
-      this.indices = i;
-      grew = true;
-    }
-    if (grew) {
-      this.generation++;
-      this.uploadedVertices = 0;
-      this.uploadedIndices = 0;
-    }
+    this.vertexStore.reserve(this.vertexCount + extraV);
+    this.indexStore.reserve(this.indexCount + extraI);
   }
 
   appendVertices(mesh) {
     const n = mesh.vertexCount;
     const base = this.vertexCount;
-    const v = this.vertices;
     const p = mesh.positions, nr = mesh.normals, t = mesh.uvs;
-    let o = base * VERTEX_FLOATS;
-    for (let i = 0; i < n; i++) {
-      v[o] = p[i * 3];
-      v[o + 1] = p[i * 3 + 1];
-      v[o + 2] = p[i * 3 + 2];
-      v[o + 3] = nr[i * 3];
-      v[o + 4] = nr[i * 3 + 1];
-      v[o + 5] = nr[i * 3 + 2];
-      v[o + 6] = t[i * 2];
-      v[o + 7] = t[i * 2 + 1];
-      o += VERTEX_FLOATS;
-    }
+    this.vertexStore.forEach(base, base + n, (first, v) => {
+      const count = v.length / VERTEX_FLOATS;
+      let o = 0;
+      for (let i = first - base, end = i + count; i < end; i++) {
+        v[o] = p[i * 3];
+        v[o + 1] = p[i * 3 + 1];
+        v[o + 2] = p[i * 3 + 2];
+        v[o + 3] = nr[i * 3];
+        v[o + 4] = nr[i * 3 + 1];
+        v[o + 5] = nr[i * 3 + 2];
+        v[o + 6] = t[i * 2];
+        v[o + 7] = t[i * 2 + 1];
+        o += VERTEX_FLOATS;
+      }
+    });
     this.vertexCount += n;
     return base;
   }
 
   appendIndices(src, base) {
     const first = this.indexCount;
-    const dst = this.indices;
-    for (let i = 0; i < src.length; i++) dst[first + i] = src[i] + base;
+    this.indexStore.forEach(first, first + src.length, (at, dst) => {
+      const off = at - first;
+      for (let i = 0; i < dst.length; i++) dst[i] = src[off + i] + base;
+    });
     this.indexCount += src.length;
     return first;
   }
 
+  /** Visit stored vertices [start, end) chunk by chunk: fn(firstVertex, Float32Array). */
+  forEachVertices(start, end, fn) {
+    this.vertexStore.forEach(start, end, fn);
+  }
+
+  /** Visit stored indices [start, end) chunk by chunk: fn(firstIndex, Uint32Array). */
+  forEachIndices(start, end, fn) {
+    this.indexStore.forEach(start, end, fn);
+  }
+
   /** Range of a mesh's primitives (triangles or lines). */
   meshRange(mesh) {
     let r = this.ranges.get(mesh);

package/src/render/renderer.js

@@ -5,7 +5,7 @@
 // The facade is the only renderer API used by the application and the
 // benchmark; backends never see the ES3D document, only a RenderScene.
 
-import { GeometryPool } from './geometry-pool.js';
+import { GeometryPool, VERTEX_BYTES } from './geometry-pool.js';
 import { FrameBuilder } from './frame-builder.js';
 import { TextureCache } from './texture-cache.js';
 import { FRAME_FLOATS, packFrameUniforms } from './lighting.js';
@@ -106,14 +106,40 @@ export class Renderer {
   setScene(scene, meshOf, { keepGeometry = true } = {}) {
     this.scene = scene;
     this.meshOf = meshOf;
-    if (!scene || !keepGeometry || this.pool.byteSize > POOL_REPACK_BYTES) {
+    if (!scene || !keepGeometry || (!scene.parts && this.pool.byteSize > POOL_REPACK_BYTES)) {
       this.pool.reset();
+      this.pool.unusedBytes = 0;
       this.cubeRange = this.pool.meshRange(this.cube);
     }
     this.backend.releaseMaterials(new Set(scene ? scene.materials : []));
     this.stats.totalUploadBytes = 0;
   }
 
+  /**
+   * The scene set being drawn changed (a fragment placed, hidden or removed):
+   * keep every packed mesh, free the materials no part uses, and repack the
+   * pool only once most of what it holds is geometry no part draws any more.
+   * Cheap: nothing here is proportional to the scene.
+   * @param {import('../scene/scene-set.js').SceneSet} set
+   */
+  updateScene(set) {
+    for (const entry of set.takeReleased()) {
+      if (set.geomIndex.has(entry)) continue; // taken again by another part
+      for (const mesh of entry.meshes) {
+        if (!mesh) continue;
+        const r = this.pool.ranges.get(mesh);
+        if (r) this.pool.unusedBytes = (this.pool.unusedBytes || 0) + mesh.vertexCount * VERTEX_BYTES + r.indexCount * 4;
+      }
+    }
+    if (this.pool.byteSize > POOL_REPACK_BYTES && (this.pool.unusedBytes || 0) * 2 > this.pool.byteSize) {
+      this.pool.reset();
+      this.pool.unusedBytes = 0;
+      this.cubeRange = this.pool.meshRange(this.cube);
+    }
+    if (this.materialsSeen !== set.materials.length || set.freeMaterials.length) this.backend.releaseMaterials(new Set(set.materials));
+    this.materialsSeen = set.materials.length;
+  }
+
   /**
    * Render one frame.
    * @param {import('./camera.js').Camera} camera