@es3d/es3d 1.1.2 → 1.2.1

package/src/render/webgl2/webgl2-backend.js

@@ -171,12 +171,8 @@ export class WebGL2Backend {
     this.vao = gl.createVertexArray();
     gl.bindVertexArray(this.vao);
     gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
-    gl.enableVertexAttribArray(0);
-    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, VERTEX_BYTES, 0);
-    gl.enableVertexAttribArray(1);
-    gl.vertexAttribPointer(1, 3, gl.FLOAT, false, VERTEX_BYTES, 12);
-    gl.enableVertexAttribArray(2);
-    gl.vertexAttribPointer(2, 2, gl.FLOAT, false, VERTEX_BYTES, 24);
+    for (let k = 0; k < 3; k++) gl.enableVertexAttribArray(k);
+    this.bindVertexAttributes();
     gl.bindBuffer(gl.ARRAY_BUFFER, this.instanceBuffer);
     for (let k = 0; k < 4; k++) {
       gl.enableVertexAttribArray(3 + k);
@@ -215,14 +211,28 @@ export class WebGL2Backend {
     this.gl.deleteTexture(t);
   }
 
-  /** Upload geometry appended to the pool since the last sync. */
+  /** Point the VAO's vertex attributes at the vertex buffer bound to ARRAY_BUFFER. */
+  bindVertexAttributes() {
+    const gl = this.gl;
+    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, VERTEX_BYTES, 0);
+    gl.vertexAttribPointer(1, 3, gl.FLOAT, false, VERTEX_BYTES, 12);
+    gl.vertexAttribPointer(2, 2, gl.FLOAT, false, VERTEX_BYTES, 24);
+  }
+
+  /**
+   * Upload geometry appended to the pool since the last sync.
+   *
+   * A new pool generation (reset, repack, rebuilt context) reallocates both
+   * buffers and uploads everything. A pool that only grew keeps its content:
+   * the buffer that ran out of room is replaced by a larger one, the bytes
+   * already uploaded are copied on the GPU, and only new data is sent.
+   */
   syncPool(pool) {
     const gl = this.gl;
-    const vBytes = pool.vertices.byteLength;
-    const iBytes = pool.indices.byteLength;
-    const realloc = pool.generation !== this.poolGeneration || vBytes !== this.vertexCapacity || iBytes !== this.indexCapacity;
+    const vBytes = pool.vertexCapacityBytes;
+    const iBytes = pool.indexCapacityBytes;
     let uploaded = 0;
-    if (realloc) {
+    if (pool.generation !== this.poolGeneration) {
       gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
       gl.bufferData(gl.ARRAY_BUFFER, vBytes, gl.STATIC_DRAW);
       gl.bindVertexArray(this.vao);
@@ -234,25 +244,67 @@ export class WebGL2Backend {
       this.poolGeneration = pool.generation;
       pool.uploadedVertices = 0;
       pool.uploadedIndices = 0;
+    } else {
+      if (vBytes > this.vertexCapacity) {
+        const old = this.vertexBuffer;
+        const next = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, next);
+        gl.bufferData(gl.ARRAY_BUFFER, vBytes, gl.STATIC_DRAW);
+        gl.bindVertexArray(this.vao);
+        this.bindVertexAttributes();
+        gl.bindVertexArray(null);
+        this.copyBuffer(old, next, pool.uploadedVertices * VERTEX_BYTES);
+        gl.deleteBuffer(old);
+        this.vertexBuffer = next;
+        this.vertexCapacity = vBytes;
+      }
+      if (iBytes > this.indexCapacity) {
+        // An index buffer must first be bound as ELEMENT_ARRAY_BUFFER (WebGL2
+        // types buffers on first bind); bind it through the VAO, which keeps it.
+        const old = this.indexBuffer;
+        const next = gl.createBuffer();
+        gl.bindVertexArray(this.vao);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, next);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, iBytes, gl.STATIC_DRAW);
+        gl.bindVertexArray(null);
+        this.copyBuffer(old, next, pool.uploadedIndices * 4);
+        gl.deleteBuffer(old);
+        this.indexBuffer = next;
+        this.indexCapacity = iBytes;
+      }
     }
     const p = pool.pending();
     if (p.vertexEnd > p.vertexStart) {
       gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
-      const f = 8;
-      gl.bufferSubData(gl.ARRAY_BUFFER, p.vertexStart * VERTEX_BYTES, pool.vertices.subarray(p.vertexStart * f, p.vertexEnd * f));
-      uploaded += (p.vertexEnd - p.vertexStart) * VERTEX_BYTES;
+      pool.forEachVertices(p.vertexStart, p.vertexEnd, (first, data) => {
+        gl.bufferSubData(gl.ARRAY_BUFFER, first * VERTEX_BYTES, data);
+        uploaded += data.byteLength;
+      });
     }
     if (p.indexEnd > p.indexStart) {
       gl.bindVertexArray(this.vao);
       gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
-      gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, p.indexStart * 4, pool.indices.subarray(p.indexStart, p.indexEnd));
+      pool.forEachIndices(p.indexStart, p.indexEnd, (first, data) => {
+        gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, first * 4, data);
+        uploaded += data.byteLength;
+      });
       gl.bindVertexArray(null);
-      uploaded += (p.indexEnd - p.indexStart) * 4;
     }
     pool.markUploaded();
     return uploaded;
   }
 
+  /** Copy the first `bytes` of one buffer into another, on the GPU. */
+  copyBuffer(from, to, bytes) {
+    if (bytes <= 0) return;
+    const gl = this.gl;
+    gl.bindBuffer(gl.COPY_READ_BUFFER, from);
+    gl.bindBuffer(gl.COPY_WRITE_BUFFER, to);
+    gl.copyBufferSubData(gl.COPY_READ_BUFFER, gl.COPY_WRITE_BUFFER, 0, 0, bytes);
+    gl.bindBuffer(gl.COPY_READ_BUFFER, null);
+    gl.bindBuffer(gl.COPY_WRITE_BUFFER, null);
+  }
+
   uploadInstances(data, count) {
     const gl = this.gl;
     const bytes = count * 64;

package/src/render/webgpu/webgpu-backend.js

@@ -254,30 +254,61 @@ export class WebGPUBackend {
     });
   }
 
+  /**
+   * Upload geometry appended to the pool since the last sync.
+   *
+   * A new pool generation (reset, repack) reallocates both buffers and uploads
+   * everything. A pool that only grew keeps its content: the buffer that ran
+   * out of room is replaced by a larger one, the bytes already uploaded are
+   * copied on the GPU, and only new data is sent.
+   */
   syncPool(pool) {
     const d = this.device;
-    const vBytes = pool.vertices.byteLength;
-    const iBytes = pool.indices.byteLength;
+    const vBytes = pool.vertexCapacityBytes;
+    const iBytes = pool.indexCapacityBytes;
+    const vUsage = GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+    const iUsage = GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
     let uploaded = 0;
-    if (pool.generation !== this.poolGeneration || !this.vertexBuffer || this.vertexBuffer.size < vBytes || this.indexBuffer.size < iBytes) {
+    if (pool.generation !== this.poolGeneration || !this.vertexBuffer) {
       if (this.vertexBuffer) this.vertexBuffer.destroy();
       if (this.indexBuffer) this.indexBuffer.destroy();
-      this.vertexBuffer = d.createBuffer({ size: pow2(vBytes, 1 << 16), usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });
-      this.indexBuffer = d.createBuffer({ size: pow2(iBytes, 1 << 16), usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST });
+      this.vertexBuffer = d.createBuffer({ size: pow2(vBytes, 1 << 16), usage: vUsage });
+      this.indexBuffer = d.createBuffer({ size: pow2(iBytes, 1 << 16), usage: iUsage });
       this.poolGeneration = pool.generation;
       pool.uploadedVertices = 0;
       pool.uploadedIndices = 0;
+    } else {
+      let encoder = null;
+      const grow = (old, bytes, usage, keep) => {
+        const next = d.createBuffer({ size: pow2(bytes, 1 << 16), usage });
+        if (keep > 0) {
+          encoder ||= d.createCommandEncoder();
+          encoder.copyBufferToBuffer(old, 0, next, 0, keep);
+        }
+        return next;
+      };
+      const oldV = this.vertexBuffer.size < vBytes ? this.vertexBuffer : null;
+      const oldI = this.indexBuffer.size < iBytes ? this.indexBuffer : null;
+      if (oldV) this.vertexBuffer = grow(oldV, vBytes, vUsage, pool.uploadedVertices * VERTEX_BYTES);
+      if (oldI) this.indexBuffer = grow(oldI, iBytes, iUsage, pool.uploadedIndices * 4);
+      // the copy is queued before the writes below, so the new data lands after it;
+      // destroying a buffer waits for submitted work that reads it
+      if (encoder) d.queue.submit([encoder.finish()]);
+      if (oldV) oldV.destroy();
+      if (oldI) oldI.destroy();
     }
     const p = pool.pending();
     if (p.vertexEnd > p.vertexStart) {
-      const src = pool.vertices.subarray(p.vertexStart * 8, p.vertexEnd * 8);
-      d.queue.writeBuffer(this.vertexBuffer, p.vertexStart * VERTEX_BYTES, src.buffer, src.byteOffset, src.byteLength);
-      uploaded += src.byteLength;
+      pool.forEachVertices(p.vertexStart, p.vertexEnd, (first, src) => {
+        d.queue.writeBuffer(this.vertexBuffer, first * VERTEX_BYTES, src.buffer, src.byteOffset, src.byteLength);
+        uploaded += src.byteLength;
+      });
     }
     if (p.indexEnd > p.indexStart) {
-      const src = pool.indices.subarray(p.indexStart, p.indexEnd);
-      d.queue.writeBuffer(this.indexBuffer, p.indexStart * 4, src.buffer, src.byteOffset, src.byteLength);
-      uploaded += src.byteLength;
+      pool.forEachIndices(p.indexStart, p.indexEnd, (first, src) => {
+        d.queue.writeBuffer(this.indexBuffer, first * 4, src.buffer, src.byteOffset, src.byteLength);
+        uploaded += src.byteLength;
+      });
     }
     pool.markUploaded();
     return uploaded;

package/src/render/worker-boot.js

@@ -0,0 +1,14 @@
+// The first module the stage evaluates (render/stage.js imports it before
+// anything else). In the compiler worker it keeps every message that arrives
+// before the compiler is ready: the WebAssembly kernels (wasm/kernels.js) are
+// instantiated with a top-level await, and a module worker delivers messages
+// while it waits, so a handler installed after that would miss the first
+// requests. compile-worker.js answers the kept messages once it takes over.
+
+/** True inside a dedicated worker. */
+export const inWorker = typeof WorkerGlobalScope !== 'undefined' && typeof self !== 'undefined' && self instanceof WorkerGlobalScope;
+
+/** Messages that arrived before the compiler was ready, oldest first. */
+export const early = [];
+
+if (inWorker) self.onmessage = (e) => early.push(e);