@onerjs/core 8.55.9 → 8.56.1

package/Materials/uniformBuffer.js

@@ -41,6 +41,7 @@ export class UniformBuffer {
         this._uniformArraySizes = {};
         this._uniformLocationPointer = 0;
         this._needSync = false;
+        this._dataGeneration = 0;
         this._trackUBOsInFrame = false;
         if ((trackUBOsInFrame === undefined && this._engine._features.trackUbosInFrame) || trackUBOsInFrame === true) {
             this._buffers = [];
@@ -49,6 +50,7 @@ export class UniformBuffer {
             this._createBufferOnWrite = false;
             this._currentFrameId = 0;
             this._trackUBOsInFrame = true;
+            this._resetOwnerSlots();
         }
         if (this._noUBO) {
             this.updateMatrix3x3 = this._updateMatrix3x3ForEffect;
@@ -328,6 +330,7 @@ export class UniformBuffer {
         // See spec, alignment must be filled as a vec4
         this._fillAlignment(4);
         this._bufferData = new Float32Array(this._data);
+        this._dataGeneration++;
         this._rebuild();
         this._needSync = true;
     }
@@ -368,9 +371,23 @@ export class UniformBuffer {
         if (this._trackUBOsInFrame) {
             this._buffers = [];
             this._currentFrameId = 0;
+            this._resetOwnerSlots();
         }
         this._rebuild();
     }
+    _resetOwnerSlots() {
+        if (this._ownerListsBySlot) {
+            for (const list of this._ownerListsBySlot.values()) {
+                this._removeOwnerBacklink(list);
+            }
+        }
+        this._ownerListsBySlot = new Map();
+        this._slotByOwner = new WeakMap();
+        this._slotFrameId = [];
+        this._ownerCount = 0;
+        this._freeSlots = [];
+        this._slotGeneration = [];
+    }
     /** @internal */
     get _numBuffers() {
         return this._buffers.length;
@@ -436,6 +453,122 @@ export class UniformBuffer {
         this._needSync = false;
         this._createBufferOnWrite = this._trackUBOsInFrame;
     }
+    /**
+     * Flushes the current uniform values into the GPU buffer owned by the draw context.
+     * Invariant: `_buffers[i][1]` (the CPU shadow) always holds what the GPU buffer of slot i contains.
+     * @param owner the draw context on behalf of which the update is done
+     * @internal
+     */
+    _updateOwnerKeyed(owner) {
+        if (this._noUBO || !this._trackUBOsInFrame) {
+            this.update();
+            return;
+        }
+        if (!this._buffer) {
+            this.create(); // _rebuild pushes slot 0, created from _bufferData, with a shadow copy of it
+        }
+        this._checkNewFrame();
+        let idx = this._slotByOwner.get(owner);
+        if (idx === undefined) {
+            if (this._ownerCount === 0 && this._buffers.length === 1 && this._freeSlots.length === 0) {
+                // the slot create() made and nobody has owned yet: hand it to the first owner instead of leaving it unused.
+                // (Once an owner has released it, it is in _freeSlots and must be taken from there, or two owners could share it.)
+                idx = 0;
+            }
+            else {
+                idx = this._takeFreeSlot(true);
+            }
+            this._slotByOwner.set(owner, idx);
+            this._ownerCount++;
+            if (!owner._uniformBuffersWithOwnedSlot) {
+                owner._uniformBuffersWithOwnedSlot = [];
+            }
+            owner._uniformBuffersWithOwnedSlot.push(this);
+            this._ownerListsBySlot.set(idx, owner._uniformBuffersWithOwnedSlot);
+        }
+        if (this._slotGeneration[idx] === this._dataGeneration) {
+            // The slot was last flushed with exactly the current data and nothing has been written since: nothing to
+            // compare, nothing to upload, and no same-frame conflict is possible either (same bytes).
+            this._bufferIndex = idx;
+            this._buffer = this._buffers[idx][0];
+            this.bindUniformBuffer();
+            this._slotFrameId[idx] = this._currentFrameId;
+            this._needSync = false;
+            this._createBufferOnWrite = false;
+            return;
+        }
+        const owned = this._buffers[idx][1];
+        if (this._slotFrameId[idx] === this._currentFrameId && owned && !this._buffersEqual(this._bufferData, owned)) {
+            // The same context flushes a second time in the same frame with different values: the GPU has not consumed the
+            // first values yet, so they must not be overwritten. Use a slot nobody owns for this flush.
+            idx = this._takeFreeSlot(false);
+        }
+        this._bufferIndex = idx;
+        this._buffer = this._buffers[idx][0];
+        this.bindUniformBuffer();
+        const shadow = this._buffers[idx][1];
+        if (!shadow || !this._buffersEqual(this._bufferData, shadow)) {
+            if (shadow) {
+                this._copyBuffer(this._bufferData, shadow);
+            }
+            this._bufferUpdatedLastFrame = true;
+            this._engine.updateUniformBuffer(this._buffer, this._bufferData);
+        }
+        this._slotFrameId[idx] = this._currentFrameId;
+        this._slotGeneration[idx] = this._dataGeneration;
+        this._needSync = false;
+        this._createBufferOnWrite = false; // slots are keyed on the owner, the updateXXX methods must never switch buffer
+    }
+    /**
+     * Gets a slot that is not owned by any draw context and has not been flushed in the current frame, creating one if needed.
+     * @param takeOwnership true to remove the slot from the free list (it is going to be owned by a context)
+     * @returns the slot index
+     */
+    _takeFreeSlot(takeOwnership) {
+        for (let i = 0; i < this._freeSlots.length; ++i) {
+            const idx = this._freeSlots[i];
+            if (this._slotFrameId[idx] !== this._currentFrameId) {
+                if (takeOwnership) {
+                    this._freeSlots[i] = this._freeSlots[this._freeSlots.length - 1];
+                    this._freeSlots.pop();
+                }
+                return idx;
+            }
+        }
+        this._rebuild();
+        const idx = this._buffers.length - 1;
+        if (!takeOwnership) {
+            this._freeSlots.push(idx);
+        }
+        return idx;
+    }
+    /**
+     * Releases the slot owned by a draw context (called when the context is disposed), so that another context can reuse it.
+     * @param owner the draw context
+     * @internal
+     */
+    _releaseOwnerSlot(owner) {
+        const idx = this._slotByOwner?.get(owner);
+        if (idx === undefined) {
+            return;
+        }
+        this._slotByOwner.delete(owner);
+        const list = this._ownerListsBySlot.get(idx);
+        if (list) {
+            this._removeOwnerBacklink(list);
+            this._ownerListsBySlot.delete(idx);
+        }
+        this._ownerCount--;
+        // Keep _slotFrameId: a draw encoded earlier this frame may still need these bytes.
+        this._freeSlots.push(idx);
+    }
+    _removeOwnerBacklink(list) {
+        const index = list.indexOf(this);
+        if (index !== -1) {
+            list[index] = list[list.length - 1];
+            list.pop();
+        }
+    }
     _createNewBuffer() {
         if (this._bufferIndex + 1 < this._buffers.length) {
             this._bufferIndex++;
@@ -502,12 +635,16 @@ export class UniformBuffer {
                 }
             }
             this._needSync = this._needSync || changed;
+            if (changed) {
+                this._dataGeneration++;
+            }
         }
         else {
             // No cache for dynamic
             for (let i = 0; i < size; i++) {
                 this._bufferData[location + i] = data[i];
             }
+            this._dataGeneration++;
         }
     }
     /**
@@ -550,12 +687,16 @@ export class UniformBuffer {
                 }
             }
             this._needSync = this._needSync || changed;
+            if (changed) {
+                this._dataGeneration++;
+            }
         }
         else {
             // No cache for dynamic
             for (let i = 0; i < size; i++) {
                 this._bufferData[location + i] = data[i];
             }
+            this._dataGeneration++;
         }
     }
     _cacheMatrix(name, matrix) {
@@ -875,6 +1016,7 @@ export class UniformBuffer {
                 // Note that if _buffers.length == 1, we don't copy _bufferData into _buffers[_bufferIndex][1] (see the update() method), and _bufferData already contains the right data
                 if (this._buffers.length > 1 && this._buffers[b][1]) {
                     this._bufferData.set(this._buffers[b][1]);
+                    this._dataGeneration++;
                 }
                 this._valueCache = {};
                 // The following line prevents the current buffer (_buffer / _bufferIndex) from being updated during subsequent calls to updateXXX() due to a call to _checkNewFrame()
@@ -910,10 +1052,14 @@ export class UniformBuffer {
                 uniformBuffers.pop();
             }
             if (this._trackUBOsInFrame && this._buffers) {
+                this._resetOwnerSlots();
                 for (let i = 0; i < this._buffers.length; ++i) {
                     const buffer = this._buffers[i][0];
                     this._engine._releaseBuffer(buffer);
                 }
+                this._buffers = [];
+                this._buffer = null;
+                this._bufferIndex = -1;
             }
             else if (this._buffer && this._engine._releaseBuffer(this._buffer)) {
                 this._buffer = null;