@babylonjs/loaders 9.13.0 → 9.15.0

package/SPLAT/gaussianSplattingBlockAllocator.js

@@ -0,0 +1,555 @@
+/**
+ * A node in the {@link GaussianSplattingBlockAllocator}'s linked list, representing either an allocated
+ * block or a free region. Callers receive {@link GaussianSplattingMemBlock} instances as handles from
+ * {@link GaussianSplattingBlockAllocator.allocate} and must treat their {@link offset}/{@link size} as
+ * read-only.
+ *
+ * Ported from the PlayCanvas engine (`src/core/block-allocator.js`).
+ * @experimental
+ */
+export class GaussianSplattingMemBlock {
+    constructor() {
+        /** @internal Position in the address space. */
+        this._offset = 0;
+        /** @internal Size of this block. */
+        this._size = 0;
+        /** @internal True if this is a free region, false if allocated. */
+        this._free = true;
+        /** @internal Previous node in the main (all-nodes, offset-ordered) list. */
+        this._prev = null;
+        /** @internal Next node in the main (all-nodes, offset-ordered) list. */
+        this._next = null;
+        /** @internal Previous node in the bucket free-list. */
+        this._prevFree = null;
+        /** @internal Next node in the bucket free-list. */
+        this._nextFree = null;
+        /** @internal Index of the size bucket this free block belongs to, or -1 if not in any bucket. */
+        this._bucket = -1;
+    }
+    /**
+     * The offset of this block in the address space.
+     */
+    get offset() {
+        return this._offset;
+    }
+    /**
+     * The size of this block.
+     */
+    get size() {
+        return this._size;
+    }
+}
+/**
+ * A general-purpose 1D block allocator backed by a doubly-linked list with segregated free-list buckets.
+ * Manages a linear address space where contiguous blocks can be allocated and freed.
+ *
+ * Free blocks are organized into power-of-2 size buckets for best-fit allocation, which reduces
+ * fragmentation compared to a single first-fit free list. Supports incremental defragmentation and
+ * automatic growth. Used to place streamed Gaussian Splatting LOD files into the unified GPU work buffer.
+ *
+ * Ported from the PlayCanvas engine (`src/core/block-allocator.js`).
+ * @experimental
+ */
+export class GaussianSplattingBlockAllocator {
+    /**
+     * Creates a new block allocator.
+     * @param capacity initial address space capacity (defaults to 0)
+     * @param growMultiplier multiplicative growth factor for auto-grow in {@link updateAllocation} (defaults to 1.1)
+     */
+    constructor(capacity = 0, growMultiplier = 1.1) {
+        // Head/tail of the main list (all blocks, offset-ordered).
+        this._headAll = null;
+        this._tailAll = null;
+        // Segregated free-list bucket heads. Bucket i covers sizes [2^i, 2^(i+1)). Grows as larger free blocks appear.
+        this._freeBucketHeads = [];
+        // Pool of recycled MemBlock objects.
+        this._pool = [];
+        this._capacity = 0;
+        this._usedSize = 0;
+        this._freeSize = 0;
+        // Number of free regions; maintained O(1) for the fragmentation metric.
+        this._freeRegionCount = 0;
+        this._growMultiplier = growMultiplier;
+        if (capacity > 0) {
+            this._capacity = capacity;
+            this._freeSize = capacity;
+            const block = this._obtain(0, capacity, true);
+            this._headAll = block;
+            this._tailAll = block;
+            this._addToBucket(block);
+        }
+    }
+    /**
+     * Total address space capacity.
+     */
+    get capacity() {
+        return this._capacity;
+    }
+    /**
+     * Total size of all allocated blocks.
+     */
+    get usedSize() {
+        return this._usedSize;
+    }
+    /**
+     * Total size of all free regions.
+     */
+    get freeSize() {
+        return this._freeSize;
+    }
+    /**
+     * Fragmentation ratio in the range [0, 1]. Returns 0 when all free space is one contiguous block
+     * (ideal), and approaches 1 when free space is split into many pieces. Computed O(1).
+     */
+    get fragmentation() {
+        return this._freeSize > 0 ? 1 - 1 / this._freeRegionCount : 0;
+    }
+    /**
+     * Allocates a contiguous block of the given size.
+     * @param size the number of units to allocate (must be \> 0)
+     * @returns a block handle, or null if no space is available
+     */
+    allocate(size) {
+        if (size <= 0) {
+            return null;
+        }
+        const gap = this._findFreeBlock(size);
+        if (!gap) {
+            return null;
+        }
+        this._usedSize += size;
+        this._freeSize -= size;
+        if (gap._size === size) {
+            // Perfect fit: convert free block to allocated.
+            gap._free = false;
+            this._removeFromBucket(gap);
+            return gap;
+        }
+        // Split: create allocated block at start of gap, shrink gap.
+        const alloc = this._obtain(gap._offset, size, false);
+        gap._offset += size;
+        gap._size -= size;
+        this._rebucket(gap);
+        this._insertAfterInMainList(alloc, gap._prev);
+        return alloc;
+    }
+    /**
+     * Frees a previously allocated block. Adjacent free regions are merged automatically.
+     * @param block the block to free (must have been returned by {@link allocate})
+     */
+    free(block) {
+        if (!block || block._free) {
+            return;
+        }
+        block._free = true;
+        this._usedSize -= block._size;
+        this._freeSize += block._size;
+        const prev = block._prev;
+        const next = block._next;
+        const prevFree = prev && prev._free;
+        const nextFree = next && next._free;
+        if (prevFree && nextFree) {
+            // Both neighbors free: merge all three into prev.
+            prev._size += block._size + next._size;
+            this._removeFromMainList(block);
+            this._removeFromMainList(next);
+            this._removeFromBucket(next);
+            this._release(block);
+            this._release(next);
+            this._rebucket(prev);
+        }
+        else if (prevFree) {
+            // Left neighbor free: merge into prev.
+            prev._size += block._size;
+            this._removeFromMainList(block);
+            this._release(block);
+            this._rebucket(prev);
+        }
+        else if (nextFree) {
+            // Right neighbor free: absorb right into block.
+            block._size += next._size;
+            this._removeFromMainList(next);
+            this._removeFromBucket(next);
+            this._release(next);
+            this._addToBucket(block);
+        }
+        else {
+            // Neither neighbor free: insert into bucket.
+            this._addToBucket(block);
+        }
+    }
+    /**
+     * Grows the address space. Only increases capacity, never decreases.
+     * @param newCapacity the new capacity (must be \> current capacity)
+     */
+    grow(newCapacity) {
+        if (newCapacity <= this._capacity) {
+            return;
+        }
+        const added = newCapacity - this._capacity;
+        this._capacity = newCapacity;
+        this._freeSize += added;
+        if (this._tailAll && this._tailAll._free) {
+            // Extend existing tail free block.
+            this._tailAll._size += added;
+            this._rebucket(this._tailAll);
+        }
+        else {
+            // Append new free block.
+            const block = this._obtain(this._capacity - added, added, true);
+            this._insertAfterInMainList(block, this._tailAll);
+            this._addToBucket(block);
+        }
+    }
+    /**
+     * Defragments the allocator by moving allocated blocks to reduce fragmentation.
+     *
+     * When maxMoves is 0, performs a full compaction in a single O(n) pass: all allocated blocks are packed
+     * contiguously from offset 0 and a single free block is placed at the end. When maxMoves \> 0, performs
+     * incremental defragmentation (relocate the last block into the first fitting gap, then slide blocks left).
+     *
+     * Moved blocks have their {@link GaussianSplattingMemBlock.offset} updated in place (handles stay valid),
+     * so callers must relocate the corresponding GPU data for every block in the returned set.
+     * @param maxMoves maximum number of block moves (0 = full compaction, the default)
+     * @param result optional set to receive the moved blocks (defaults to a new set)
+     * @returns the set of blocks that were moved
+     */
+    defrag(maxMoves = 0, result = new Set()) {
+        result.clear();
+        if (this._freeRegionCount === 0) {
+            return result;
+        }
+        if (maxMoves === 0) {
+            this._defragFull(result);
+        }
+        else {
+            this._defragIncremental(maxMoves, result);
+        }
+        return result;
+    }
+    /**
+     * Batch update: frees a set of blocks and allocates new ones. Handles growth and compaction internally
+     * when allocations cannot be satisfied. The `toAllocate` array is modified in place: each numeric size
+     * entry is replaced with the allocated block.
+     * @param toFree blocks to release
+     * @param toAllocate sizes to allocate; modified in place (numbers are replaced with block handles)
+     * @returns true if a full defrag was performed (all existing blocks have new offsets and must be re-rendered)
+     */
+    updateAllocation(toFree, toAllocate) {
+        // Phase 1: free old blocks.
+        for (let i = 0; i < toFree.length; i++) {
+            this.free(toFree[i]);
+        }
+        // Phase 2: try to allocate all new blocks.
+        for (let i = 0; i < toAllocate.length; i++) {
+            const size = toAllocate[i];
+            const block = this.allocate(size);
+            if (block) {
+                toAllocate[i] = block;
+            }
+            else {
+                // Allocation failed at index i; entries [0..i-1] are blocks, [i..n-1] are still numbers.
+                let totalRemaining = size;
+                for (let j = i + 1; j < toAllocate.length; j++) {
+                    totalRemaining += toAllocate[j];
+                }
+                // Grow if the free space would be below the headroom threshold.
+                const neededCapacity = this._usedSize + totalRemaining;
+                const headroomCapacity = Math.ceil(neededCapacity * this._growMultiplier);
+                if (headroomCapacity > this._capacity) {
+                    this.grow(headroomCapacity);
+                }
+                // Full defrag: compact everything, then allocate the remainder (guaranteed to succeed).
+                this.defrag(0);
+                for (let j = i; j < toAllocate.length; j++) {
+                    toAllocate[j] = this.allocate(toAllocate[j]);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Computes the bucket index for a given block size (= floor(log2(size))).
+     * @param size block size (must be \> 0)
+     * @returns the bucket index
+     */
+    _bucketFor(size) {
+        return 31 - Math.clz32(size);
+    }
+    _addToBucket(block) {
+        const b = this._bucketFor(block._size);
+        block._bucket = b;
+        while (b >= this._freeBucketHeads.length) {
+            this._freeBucketHeads.push(null);
+        }
+        block._prevFree = null;
+        block._nextFree = this._freeBucketHeads[b];
+        if (this._freeBucketHeads[b]) {
+            this._freeBucketHeads[b]._prevFree = block;
+        }
+        this._freeBucketHeads[b] = block;
+        this._freeRegionCount++;
+    }
+    _removeFromBucket(block) {
+        const b = block._bucket;
+        if (block._prevFree) {
+            block._prevFree._nextFree = block._nextFree;
+        }
+        else {
+            this._freeBucketHeads[b] = block._nextFree;
+        }
+        if (block._nextFree) {
+            block._nextFree._prevFree = block._prevFree;
+        }
+        block._prevFree = null;
+        block._nextFree = null;
+        block._bucket = -1;
+        this._freeRegionCount--;
+    }
+    _rebucket(block) {
+        const newBucket = this._bucketFor(block._size);
+        if (newBucket !== block._bucket) {
+            this._removeFromBucket(block);
+            this._addToBucket(block);
+        }
+    }
+    _obtain(offset, size, free) {
+        const block = this._pool.length > 0 ? this._pool.pop() : new GaussianSplattingMemBlock();
+        block._offset = offset;
+        block._size = size;
+        block._free = free;
+        block._prev = null;
+        block._next = null;
+        block._prevFree = null;
+        block._nextFree = null;
+        block._bucket = -1;
+        return block;
+    }
+    _release(block) {
+        block._prev = null;
+        block._next = null;
+        block._prevFree = null;
+        block._nextFree = null;
+        block._bucket = -1;
+        this._pool.push(block);
+    }
+    _insertAfterInMainList(block, after) {
+        if (after === null) {
+            block._prev = null;
+            block._next = this._headAll;
+            if (this._headAll) {
+                this._headAll._prev = block;
+            }
+            this._headAll = block;
+            if (!this._tailAll) {
+                this._tailAll = block;
+            }
+        }
+        else {
+            block._prev = after;
+            block._next = after._next;
+            if (after._next) {
+                after._next._prev = block;
+            }
+            after._next = block;
+            if (this._tailAll === after) {
+                this._tailAll = block;
+            }
+        }
+    }
+    _removeFromMainList(block) {
+        if (block._prev) {
+            block._prev._next = block._next;
+        }
+        else {
+            this._headAll = block._next;
+        }
+        if (block._next) {
+            block._next._prev = block._prev;
+        }
+        else {
+            this._tailAll = block._prev;
+        }
+        block._prev = null;
+        block._next = null;
+    }
+    _findFreeBlock(size) {
+        const startBucket = this._bucketFor(size);
+        const len = this._freeBucketHeads.length;
+        // Target bucket: best-fit (smallest block >= size).
+        if (startBucket < len) {
+            let best = null;
+            let node = this._freeBucketHeads[startBucket];
+            while (node) {
+                if (node._size >= size) {
+                    if (!best || node._size < best._size) {
+                        best = node;
+                        if (node._size === size) {
+                            break;
+                        }
+                    }
+                }
+                node = node._nextFree;
+            }
+            if (best) {
+                return best;
+            }
+        }
+        // Higher buckets: first-fit (any block is large enough).
+        for (let b = startBucket + 1; b < len; b++) {
+            if (this._freeBucketHeads[b]) {
+                return this._freeBucketHeads[b];
+            }
+        }
+        return null;
+    }
+    _defragFull(result) {
+        // Remove all free blocks from all buckets and pool them.
+        for (let b = 0; b < this._freeBucketHeads.length; b++) {
+            let node = this._freeBucketHeads[b];
+            while (node) {
+                const nextFree = node._nextFree;
+                this._removeFromMainList(node);
+                node._prevFree = null;
+                node._nextFree = null;
+                node._bucket = -1;
+                this._pool.push(node);
+                node = nextFree;
+            }
+            this._freeBucketHeads[b] = null;
+        }
+        this._freeRegionCount = 0;
+        // Walk remaining (all allocated) blocks, assigning sequential offsets.
+        let offset = 0;
+        let block = this._headAll;
+        while (block) {
+            if (block._offset !== offset) {
+                block._offset = offset;
+                result.add(block);
+            }
+            offset += block._size;
+            block = block._next;
+        }
+        // Create a single free block at the end if there is remaining capacity.
+        const remaining = this._capacity - offset;
+        if (remaining > 0) {
+            const freeBlock = this._obtain(offset, remaining, true);
+            this._insertAfterInMainList(freeBlock, this._tailAll);
+            this._addToBucket(freeBlock);
+        }
+    }
+    _defragIncremental(maxMoves, result) {
+        const phase1Moves = Math.ceil(maxMoves / 2);
+        const phase2Moves = maxMoves - phase1Moves;
+        // Phase 1: relocate the last allocated block to the first fitting gap (maximizes tail free space).
+        for (let i = 0; i < phase1Moves; i++) {
+            let lastAlloc = this._tailAll;
+            while (lastAlloc && lastAlloc._free) {
+                lastAlloc = lastAlloc._prev;
+            }
+            if (!lastAlloc) {
+                break;
+            }
+            const gap = this._findFreeBlock(lastAlloc._size);
+            if (!gap || gap._offset >= lastAlloc._offset) {
+                break;
+            }
+            this._moveBlock(lastAlloc, gap);
+            result.add(lastAlloc);
+        }
+        // Phase 2: slide allocated blocks left into adjacent free gaps (cleans up interior fragmentation).
+        let block = this._headAll;
+        for (let i = 0; i < phase2Moves && block;) {
+            const next = block._next;
+            if (block._free && next && !next._free) {
+                const allocBlock = next;
+                const freeBlock = block;
+                allocBlock._offset = freeBlock._offset;
+                freeBlock._offset = allocBlock._offset + allocBlock._size;
+                // Swap in the main list.
+                const a = freeBlock._prev;
+                const b = allocBlock._next;
+                allocBlock._prev = a;
+                allocBlock._next = freeBlock;
+                freeBlock._prev = allocBlock;
+                freeBlock._next = b;
+                if (a) {
+                    a._next = allocBlock;
+                }
+                else {
+                    this._headAll = allocBlock;
+                }
+                if (b) {
+                    b._prev = freeBlock;
+                }
+                else {
+                    this._tailAll = freeBlock;
+                }
+                // Merge the free block with its new right neighbor if also free.
+                if (freeBlock._next && freeBlock._next._free) {
+                    const right = freeBlock._next;
+                    freeBlock._size += right._size;
+                    this._removeFromMainList(right);
+                    this._removeFromBucket(right);
+                    this._release(right);
+                    this._rebucket(freeBlock);
+                }
+                result.add(allocBlock);
+                i++;
+                // Continue from the block after freeBlock to find more opportunities.
+                block = freeBlock._next;
+            }
+            else {
+                block = next;
+            }
+        }
+    }
+    _moveBlock(block, gap) {
+        const blockSize = block._size;
+        const newOffset = gap._offset;
+        // 1. Remove the block from its current position, freeing that space.
+        const prev = block._prev;
+        this._removeFromMainList(block);
+        // Create a free region where the block was.
+        const freed = this._obtain(block._offset, blockSize, true);
+        this._insertAfterInMainList(freed, prev);
+        this._addToBucket(freed);
+        // Merge freed with its right neighbor.
+        if (freed._next && freed._next._free) {
+            const right = freed._next;
+            freed._size += right._size;
+            this._removeFromMainList(right);
+            this._removeFromBucket(right);
+            this._release(right);
+            this._rebucket(freed);
+        }
+        // Merge freed with its left neighbor.
+        if (freed._prev && freed._prev._free) {
+            const left = freed._prev;
+            left._size += freed._size;
+            this._removeFromMainList(freed);
+            this._removeFromBucket(freed);
+            this._release(freed);
+            this._rebucket(left);
+        }
+        // 2. Place the block at the gap.
+        block._offset = newOffset;
+        if (gap._size === blockSize) {
+            // Perfect fit: replace the gap with the block.
+            const gapPrev = gap._prev;
+            this._removeFromMainList(gap);
+            this._removeFromBucket(gap);
+            this._release(gap);
+            this._insertAfterInMainList(block, gapPrev);
+        }
+        else {
+            // Partial fit: shrink the gap, insert the block before it.
+            gap._offset += blockSize;
+            gap._size -= blockSize;
+            this._rebucket(gap);
+            this._insertAfterInMainList(block, gap._prev);
+        }
+    }
+}
+//# sourceMappingURL=gaussianSplattingBlockAllocator.js.map

package/SPLAT/gaussianSplattingBlockAllocator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianSplattingBlockAllocator.js","sourceRoot":"","sources":["../../../../dev/loaders/src/SPLAT/gaussianSplattingBlockAllocator.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,OAAO,yBAAyB;IAAtC;QACI,+CAA+C;QACxC,YAAO,GAAG,CAAC,CAAC;QACnB,oCAAoC;QAC7B,UAAK,GAAG,CAAC,CAAC;QACjB,mEAAmE;QAC5D,UAAK,GAAG,IAAI,CAAC;QACpB,4EAA4E;QACrE,UAAK,GAAwC,IAAI,CAAC;QACzD,wEAAwE;QACjE,UAAK,GAAwC,IAAI,CAAC;QACzD,uDAAuD;QAChD,cAAS,GAAwC,IAAI,CAAC;QAC7D,mDAAmD;QAC5C,cAAS,GAAwC,IAAI,CAAC;QAC7D,iGAAiG;QAC1F,YAAO,GAAG,CAAC,CAAC,CAAC;IAexB,CAAC;IAbG;;OAEG;IACH,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;CACJ;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,+BAA+B;IAgBxC;;;;OAIG;IACH,YAAmB,QAAQ,GAAG,CAAC,EAAE,cAAc,GAAG,GAAG;QApBrD,2DAA2D;QACnD,aAAQ,GAAwC,IAAI,CAAC;QACrD,aAAQ,GAAwC,IAAI,CAAC;QAC7D,+GAA+G;QAC9F,qBAAgB,GAA+C,EAAE,CAAC;QACnF,qCAAqC;QACpB,UAAK,GAAgC,EAAE,CAAC;QACjD,cAAS,GAAG,CAAC,CAAC;QACd,cAAS,GAAG,CAAC,CAAC;QACd,cAAS,GAAG,CAAC,CAAC;QACtB,wEAAwE;QAChE,qBAAgB,GAAG,CAAC,CAAC;QAUzB,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YACf,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;YAC1B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;YAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;YAC9C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;IACL,CAAC;IAED;;OAEG;IACH,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,IAAW,aAAa;QACpB,OAAO,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,IAAY;QACxB,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,GAAG,EAAE,CAAC;YACP,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;QACvB,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;QAEvB,IAAI,GAAG,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACrB,gDAAgD;YAChD,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC;YAClB,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAC5B,OAAO,GAAG,CAAC;QACf,CAAC;QAED,6DAA6D;QAC7D,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACrD,GAAG,CAAC,OAAO,IAAI,IAAI,CAAC;QACpB,GAAG,CAAC,KAAK,IAAI,IAAI,CAAC;QAClB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACpB,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QAC9C,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;OAGG;IACI,IAAI,CAAC,KAAgC;QACxC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YACxB,OAAO;QACX,CAAC;QAED,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC;QAE9B,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,MAAM,QAAQ,GAAG,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC;QACpC,MAAM,QAAQ,GAAG,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC;QAEpC,IAAI,QAAQ,IAAI,QAAQ,EAAE,CAAC;YACvB,kDAAkD;YAClD,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YACvC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;YAC/B,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACpB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;aAAM,IAAI,QAAQ,EAAE,CAAC;YAClB,uCAAuC;YACvC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC;YAC1B,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;aAAM,IAAI,QAAQ,EAAE,CAAC;YAClB,gDAAgD;YAChD,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC;YAC1B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;YAC/B,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACpB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACJ,6CAA6C;YAC7C,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,IAAI,CAAC,WAAmB;QAC3B,IAAI,WAAW,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAChC,OAAO;QACX,CAAC;QAED,MAAM,KAAK,GAAG,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC;QAC3C,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC;QAC7B,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC;QAExB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACvC,mCAAmC;YACnC,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,KAAK,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC;aAAM,CAAC;YACJ,yBAAyB;YACzB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;YAChE,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAClD,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,MAAM,CAAC,QAAQ,GAAG,CAAC,EAAE,SAAyC,IAAI,GAAG,EAAE;QAC1E,MAAM,CAAC,KAAK,EAAE,CAAC;QAEf,IAAI,IAAI,CAAC,gBAAgB,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,MAAM,CAAC;QAClB,CAAC;QAED,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;YACjB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC9C,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;;;OAOG;IACI,gBAAgB,CAAC,MAAmC,EAAE,UAAqD;QAC9G,4BAA4B;QAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACzB,CAAC;QAED,2CAA2C;QAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,MAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAW,CAAC;YACrC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAClC,IAAI,KAAK,EAAE,CAAC;gBACR,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;YAC1B,CAAC;iBAAM,CAAC;gBACJ,yFAAyF;gBACzF,IAAI,cAAc,GAAG,IAAI,CAAC;gBAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC7C,cAAc,IAAI,UAAU,CAAC,CAAC,CAAW,CAAC;gBAC9C,CAAC;gBAED,gEAAgE;gBAChE,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,GAAG,cAAc,CAAC;gBACvD,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC;gBAC1E,IAAI,gBAAgB,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;oBACpC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;gBAChC,CAAC;gBAED,wFAAwF;gBACxF,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACzC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAW,CAAE,CAAC;gBAC5D,CAAC;gBAED,OAAO,IAAI,CAAC;YAChB,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACK,UAAU,CAAC,IAAY;QAC3B,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAEO,YAAY,CAAC,KAAgC;QACjD,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;QAClB,OAAO,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC;YACvC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;QAC3C,IAAI,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAE,CAAC,SAAS,GAAG,KAAK,CAAC;QAChD,CAAC;QACD,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACjC,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAEO,iBAAiB,CAAC,KAAgC;QACtD,MAAM,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC;QACxB,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YAClB,KAAK,CAAC,SAAS,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QAChD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC;QAC/C,CAAC;QACD,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YAClB,KAAK,CAAC,SAAS,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QAChD,CAAC;QACD,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;QACnB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAEO,SAAS,CAAC,KAAgC;QAC9C,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,SAAS,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;YAC9B,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;IACL,CAAC;IAEO,OAAO,CAAC,MAAc,EAAE,IAAY,EAAE,IAAa;QACvD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAG,CAAC,CAAC,CAAC,IAAI,yBAAyB,EAAE,CAAC;QAC1F,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;QACvB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;QACnB,OAAO,KAAK,CAAC;IACjB,CAAC;IAEO,QAAQ,CAAC,KAAgC;QAC7C,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;QACnB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAEO,sBAAsB,CAAC,KAAgC,EAAE,KAA0C;QACvG,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACjB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;YACnB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC5B,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChB,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC;YAChC,CAAC;YACD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACjB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YAC1B,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;YACpB,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;YAC1B,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;gBACd,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;YAC9B,CAAC;YACD,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;YACpB,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;gBAC1B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YAC1B,CAAC;QACL,CAAC;IACL,CAAC;IAEO,mBAAmB,CAAC,KAAgC;QACxD,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACpC,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC;QAChC,CAAC;QACD,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACpC,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC;QAChC,CAAC;QACD,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QACnB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;IACvB,CAAC;IAEO,cAAc,CAAC,IAAY;QAC/B,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1C,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC;QAEzC,oDAAoD;QACpD,IAAI,WAAW,GAAG,GAAG,EAAE,CAAC;YACpB,IAAI,IAAI,GAAwC,IAAI,CAAC;YACrD,IAAI,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;YAC9C,OAAO,IAAI,EAAE,CAAC;gBACV,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;oBACrB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;wBACnC,IAAI,GAAG,IAAI,CAAC;wBACZ,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;4BACtB,MAAM;wBACV,CAAC;oBACL,CAAC;gBACL,CAAC;gBACD,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC;YAC1B,CAAC;YACD,IAAI,IAAI,EAAE,CAAC;gBACP,OAAO,IAAI,CAAC;YAChB,CAAC;QACL,CAAC;QAED,yDAAyD;QACzD,KAAK,IAAI,CAAC,GAAG,WAAW,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,IAAI,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,WAAW,CAAC,MAAsC;QACtD,yDAAyD;QACzD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpD,IAAI,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;YACpC,OAAO,IAAI,EAAE,CAAC;gBACV,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;gBAChC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;gBAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;gBACtB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;gBACtB,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;gBAClB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACtB,IAAI,GAAG,QAAQ,CAAC;YACpB,CAAC;YACD,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACpC,CAAC;QACD,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAE1B,uEAAuE;QACvE,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC1B,OAAO,KAAK,EAAE,CAAC;YACX,IAAI,KAAK,CAAC,OAAO,KAAK,MAAM,EAAE,CAAC;gBAC3B,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;gBACvB,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC;YACtB,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACxB,CAAC;QAED,wEAAwE;QACxE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;QAC1C,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YAChB,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;YACxD,IAAI,CAAC,sBAAsB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtD,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QACjC,CAAC;IACL,CAAC;IAEO,kBAAkB,CAAC,QAAgB,EAAE,MAAsC;QAC/E,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;QAC5C,MAAM,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;QAE3C,mGAAmG;QACnG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;YACnC,IAAI,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC9B,OAAO,SAAS,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;gBAClC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC;YAChC,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACb,MAAM;YACV,CAAC;YAED,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACjD,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;gBAC3C,MAAM;YACV,CAAC;YAED,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;YAChC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC1B,CAAC;QAED,mGAAmG;QACnG,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,IAAI,KAAK,GAAI,CAAC;YACzC,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;YAEzB,IAAI,KAAK,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACrC,MAAM,UAAU,GAAG,IAAI,CAAC;gBACxB,MAAM,SAAS,GAAG,KAAK,CAAC;gBAExB,UAAU,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;gBACvC,SAAS,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC;gBAE1D,yBAAyB;gBACzB,MAAM,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC;gBAC1B,MAAM,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC;gBAE3B,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC;gBACrB,UAAU,CAAC,KAAK,GAAG,SAAS,CAAC;gBAC7B,SAAS,CAAC,KAAK,GAAG,UAAU,CAAC;gBAC7B,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC;gBACpB,IAAI,CAAC,EAAE,CAAC;oBACJ,CAAC,CAAC,KAAK,GAAG,UAAU,CAAC;gBACzB,CAAC;qBAAM,CAAC;oBACJ,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;gBAC/B,CAAC;gBACD,IAAI,CAAC,EAAE,CAAC;oBACJ,CAAC,CAAC,KAAK,GAAG,SAAS,CAAC;gBACxB,CAAC;qBAAM,CAAC;oBACJ,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;gBAC9B,CAAC;gBAED,iEAAiE;gBACjE,IAAI,SAAS,CAAC,KAAK,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;oBAC3C,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;oBAC9B,SAAS,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC;oBAC/B,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;oBAChC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;oBAC9B,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;oBACrB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;gBAC9B,CAAC;gBAED,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBACvB,CAAC,EAAE,CAAC;gBAEJ,sEAAsE;gBACtE,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;YAC5B,CAAC;iBAAM,CAAC;gBACJ,KAAK,GAAG,IAAI,CAAC;YACjB,CAAC;QACL,CAAC;IACL,CAAC;IAEO,UAAU,CAAC,KAAgC,EAAE,GAA8B;QAC/E,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC;QAC9B,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC;QAE9B,qEAAqE;QACrE,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAEhC,4CAA4C;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QAC3D,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACzC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAEzB,uCAAuC;QACvC,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACnC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;YAC1B,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC;YAC3B,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC1B,CAAC;QACD,sCAAsC;QACtC,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;YACzB,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC;YAC1B,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAED,iCAAiC;QACjC,KAAK,CAAC,OAAO,GAAG,SAAS,CAAC;QAE1B,IAAI,GAAG,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1B,+CAA+C;YAC/C,MAAM,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC;YAC1B,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACnB,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAChD,CAAC;aAAM,CAAC;YACJ,2DAA2D;YAC3D,GAAG,CAAC,OAAO,IAAI,SAAS,CAAC;YACzB,GAAG,CAAC,KAAK,IAAI,SAAS,CAAC;YACvB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACpB,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACL,CAAC;CACJ","sourcesContent":["import { type Nullable } from \"core/types\";\r\n\r\n/**\r\n * A node in the {@link GaussianSplattingBlockAllocator}'s linked list, representing either an allocated\r\n * block or a free region. Callers receive {@link GaussianSplattingMemBlock} instances as handles from\r\n * {@link GaussianSplattingBlockAllocator.allocate} and must treat their {@link offset}/{@link size} as\r\n * read-only.\r\n *\r\n * Ported from the PlayCanvas engine (`src/core/block-allocator.js`).\r\n * @experimental\r\n */\r\nexport class GaussianSplattingMemBlock {\r\n    /** @internal Position in the address space. */\r\n    public _offset = 0;\r\n    /** @internal Size of this block. */\r\n    public _size = 0;\r\n    /** @internal True if this is a free region, false if allocated. */\r\n    public _free = true;\r\n    /** @internal Previous node in the main (all-nodes, offset-ordered) list. */\r\n    public _prev: Nullable<GaussianSplattingMemBlock> = null;\r\n    /** @internal Next node in the main (all-nodes, offset-ordered) list. */\r\n    public _next: Nullable<GaussianSplattingMemBlock> = null;\r\n    /** @internal Previous node in the bucket free-list. */\r\n    public _prevFree: Nullable<GaussianSplattingMemBlock> = null;\r\n    /** @internal Next node in the bucket free-list. */\r\n    public _nextFree: Nullable<GaussianSplattingMemBlock> = null;\r\n    /** @internal Index of the size bucket this free block belongs to, or -1 if not in any bucket. */\r\n    public _bucket = -1;\r\n\r\n    /**\r\n     * The offset of this block in the address space.\r\n     */\r\n    public get offset(): number {\r\n        return this._offset;\r\n    }\r\n\r\n    /**\r\n     * The size of this block.\r\n     */\r\n    public get size(): number {\r\n        return this._size;\r\n    }\r\n}\r\n\r\n/**\r\n * A general-purpose 1D block allocator backed by a doubly-linked list with segregated free-list buckets.\r\n * Manages a linear address space where contiguous blocks can be allocated and freed.\r\n *\r\n * Free blocks are organized into power-of-2 size buckets for best-fit allocation, which reduces\r\n * fragmentation compared to a single first-fit free list. Supports incremental defragmentation and\r\n * automatic growth. Used to place streamed Gaussian Splatting LOD files into the unified GPU work buffer.\r\n *\r\n * Ported from the PlayCanvas engine (`src/core/block-allocator.js`).\r\n * @experimental\r\n */\r\nexport class GaussianSplattingBlockAllocator {\r\n    // Head/tail of the main list (all blocks, offset-ordered).\r\n    private _headAll: Nullable<GaussianSplattingMemBlock> = null;\r\n    private _tailAll: Nullable<GaussianSplattingMemBlock> = null;\r\n    // Segregated free-list bucket heads. Bucket i covers sizes [2^i, 2^(i+1)). Grows as larger free blocks appear.\r\n    private readonly _freeBucketHeads: Array<Nullable<GaussianSplattingMemBlock>> = [];\r\n    // Pool of recycled MemBlock objects.\r\n    private readonly _pool: GaussianSplattingMemBlock[] = [];\r\n    private _capacity = 0;\r\n    private _usedSize = 0;\r\n    private _freeSize = 0;\r\n    // Number of free regions; maintained O(1) for the fragmentation metric.\r\n    private _freeRegionCount = 0;\r\n    // Multiplicative growth factor used by updateAllocation.\r\n    private readonly _growMultiplier: number;\r\n\r\n    /**\r\n     * Creates a new block allocator.\r\n     * @param capacity initial address space capacity (defaults to 0)\r\n     * @param growMultiplier multiplicative growth factor for auto-grow in {@link updateAllocation} (defaults to 1.1)\r\n     */\r\n    public constructor(capacity = 0, growMultiplier = 1.1) {\r\n        this._growMultiplier = growMultiplier;\r\n        if (capacity > 0) {\r\n            this._capacity = capacity;\r\n            this._freeSize = capacity;\r\n            const block = this._obtain(0, capacity, true);\r\n            this._headAll = block;\r\n            this._tailAll = block;\r\n            this._addToBucket(block);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Total address space capacity.\r\n     */\r\n    public get capacity(): number {\r\n        return this._capacity;\r\n    }\r\n\r\n    /**\r\n     * Total size of all allocated blocks.\r\n     */\r\n    public get usedSize(): number {\r\n        return this._usedSize;\r\n    }\r\n\r\n    /**\r\n     * Total size of all free regions.\r\n     */\r\n    public get freeSize(): number {\r\n        return this._freeSize;\r\n    }\r\n\r\n    /**\r\n     * Fragmentation ratio in the range [0, 1]. Returns 0 when all free space is one contiguous block\r\n     * (ideal), and approaches 1 when free space is split into many pieces. Computed O(1).\r\n     */\r\n    public get fragmentation(): number {\r\n        return this._freeSize > 0 ? 1 - 1 / this._freeRegionCount : 0;\r\n    }\r\n\r\n    /**\r\n     * Allocates a contiguous block of the given size.\r\n     * @param size the number of units to allocate (must be \\> 0)\r\n     * @returns a block handle, or null if no space is available\r\n     */\r\n    public allocate(size: number): Nullable<GaussianSplattingMemBlock> {\r\n        if (size <= 0) {\r\n            return null;\r\n        }\r\n\r\n        const gap = this._findFreeBlock(size);\r\n        if (!gap) {\r\n            return null;\r\n        }\r\n\r\n        this._usedSize += size;\r\n        this._freeSize -= size;\r\n\r\n        if (gap._size === size) {\r\n            // Perfect fit: convert free block to allocated.\r\n            gap._free = false;\r\n            this._removeFromBucket(gap);\r\n            return gap;\r\n        }\r\n\r\n        // Split: create allocated block at start of gap, shrink gap.\r\n        const alloc = this._obtain(gap._offset, size, false);\r\n        gap._offset += size;\r\n        gap._size -= size;\r\n        this._rebucket(gap);\r\n        this._insertAfterInMainList(alloc, gap._prev);\r\n        return alloc;\r\n    }\r\n\r\n    /**\r\n     * Frees a previously allocated block. Adjacent free regions are merged automatically.\r\n     * @param block the block to free (must have been returned by {@link allocate})\r\n     */\r\n    public free(block: GaussianSplattingMemBlock): void {\r\n        if (!block || block._free) {\r\n            return;\r\n        }\r\n\r\n        block._free = true;\r\n        this._usedSize -= block._size;\r\n        this._freeSize += block._size;\r\n\r\n        const prev = block._prev;\r\n        const next = block._next;\r\n        const prevFree = prev && prev._free;\r\n        const nextFree = next && next._free;\r\n\r\n        if (prevFree && nextFree) {\r\n            // Both neighbors free: merge all three into prev.\r\n            prev._size += block._size + next._size;\r\n            this._removeFromMainList(block);\r\n            this._removeFromMainList(next);\r\n            this._removeFromBucket(next);\r\n            this._release(block);\r\n            this._release(next);\r\n            this._rebucket(prev);\r\n        } else if (prevFree) {\r\n            // Left neighbor free: merge into prev.\r\n            prev._size += block._size;\r\n            this._removeFromMainList(block);\r\n            this._release(block);\r\n            this._rebucket(prev);\r\n        } else if (nextFree) {\r\n            // Right neighbor free: absorb right into block.\r\n            block._size += next._size;\r\n            this._removeFromMainList(next);\r\n            this._removeFromBucket(next);\r\n            this._release(next);\r\n            this._addToBucket(block);\r\n        } else {\r\n            // Neither neighbor free: insert into bucket.\r\n            this._addToBucket(block);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Grows the address space. Only increases capacity, never decreases.\r\n     * @param newCapacity the new capacity (must be \\> current capacity)\r\n     */\r\n    public grow(newCapacity: number): void {\r\n        if (newCapacity <= this._capacity) {\r\n            return;\r\n        }\r\n\r\n        const added = newCapacity - this._capacity;\r\n        this._capacity = newCapacity;\r\n        this._freeSize += added;\r\n\r\n        if (this._tailAll && this._tailAll._free) {\r\n            // Extend existing tail free block.\r\n            this._tailAll._size += added;\r\n            this._rebucket(this._tailAll);\r\n        } else {\r\n            // Append new free block.\r\n            const block = this._obtain(this._capacity - added, added, true);\r\n            this._insertAfterInMainList(block, this._tailAll);\r\n            this._addToBucket(block);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Defragments the allocator by moving allocated blocks to reduce fragmentation.\r\n     *\r\n     * When maxMoves is 0, performs a full compaction in a single O(n) pass: all allocated blocks are packed\r\n     * contiguously from offset 0 and a single free block is placed at the end. When maxMoves \\> 0, performs\r\n     * incremental defragmentation (relocate the last block into the first fitting gap, then slide blocks left).\r\n     *\r\n     * Moved blocks have their {@link GaussianSplattingMemBlock.offset} updated in place (handles stay valid),\r\n     * so callers must relocate the corresponding GPU data for every block in the returned set.\r\n     * @param maxMoves maximum number of block moves (0 = full compaction, the default)\r\n     * @param result optional set to receive the moved blocks (defaults to a new set)\r\n     * @returns the set of blocks that were moved\r\n     */\r\n    public defrag(maxMoves = 0, result: Set<GaussianSplattingMemBlock> = new Set()): Set<GaussianSplattingMemBlock> {\r\n        result.clear();\r\n\r\n        if (this._freeRegionCount === 0) {\r\n            return result;\r\n        }\r\n\r\n        if (maxMoves === 0) {\r\n            this._defragFull(result);\r\n        } else {\r\n            this._defragIncremental(maxMoves, result);\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Batch update: frees a set of blocks and allocates new ones. Handles growth and compaction internally\r\n     * when allocations cannot be satisfied. The `toAllocate` array is modified in place: each numeric size\r\n     * entry is replaced with the allocated block.\r\n     * @param toFree blocks to release\r\n     * @param toAllocate sizes to allocate; modified in place (numbers are replaced with block handles)\r\n     * @returns true if a full defrag was performed (all existing blocks have new offsets and must be re-rendered)\r\n     */\r\n    public updateAllocation(toFree: GaussianSplattingMemBlock[], toAllocate: Array<number | GaussianSplattingMemBlock>): boolean {\r\n        // Phase 1: free old blocks.\r\n        for (let i = 0; i < toFree.length; i++) {\r\n            this.free(toFree[i]);\r\n        }\r\n\r\n        // Phase 2: try to allocate all new blocks.\r\n        for (let i = 0; i < toAllocate.length; i++) {\r\n            const size = toAllocate[i] as number;\r\n            const block = this.allocate(size);\r\n            if (block) {\r\n                toAllocate[i] = block;\r\n            } else {\r\n                // Allocation failed at index i; entries [0..i-1] are blocks, [i..n-1] are still numbers.\r\n                let totalRemaining = size;\r\n                for (let j = i + 1; j < toAllocate.length; j++) {\r\n                    totalRemaining += toAllocate[j] as number;\r\n                }\r\n\r\n                // Grow if the free space would be below the headroom threshold.\r\n                const neededCapacity = this._usedSize + totalRemaining;\r\n                const headroomCapacity = Math.ceil(neededCapacity * this._growMultiplier);\r\n                if (headroomCapacity > this._capacity) {\r\n                    this.grow(headroomCapacity);\r\n                }\r\n\r\n                // Full defrag: compact everything, then allocate the remainder (guaranteed to succeed).\r\n                this.defrag(0);\r\n                for (let j = i; j < toAllocate.length; j++) {\r\n                    toAllocate[j] = this.allocate(toAllocate[j] as number)!;\r\n                }\r\n\r\n                return true;\r\n            }\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Computes the bucket index for a given block size (= floor(log2(size))).\r\n     * @param size block size (must be \\> 0)\r\n     * @returns the bucket index\r\n     */\r\n    private _bucketFor(size: number): number {\r\n        return 31 - Math.clz32(size);\r\n    }\r\n\r\n    private _addToBucket(block: GaussianSplattingMemBlock): void {\r\n        const b = this._bucketFor(block._size);\r\n        block._bucket = b;\r\n        while (b >= this._freeBucketHeads.length) {\r\n            this._freeBucketHeads.push(null);\r\n        }\r\n        block._prevFree = null;\r\n        block._nextFree = this._freeBucketHeads[b];\r\n        if (this._freeBucketHeads[b]) {\r\n            this._freeBucketHeads[b]!._prevFree = block;\r\n        }\r\n        this._freeBucketHeads[b] = block;\r\n        this._freeRegionCount++;\r\n    }\r\n\r\n    private _removeFromBucket(block: GaussianSplattingMemBlock): void {\r\n        const b = block._bucket;\r\n        if (block._prevFree) {\r\n            block._prevFree._nextFree = block._nextFree;\r\n        } else {\r\n            this._freeBucketHeads[b] = block._nextFree;\r\n        }\r\n        if (block._nextFree) {\r\n            block._nextFree._prevFree = block._prevFree;\r\n        }\r\n        block._prevFree = null;\r\n        block._nextFree = null;\r\n        block._bucket = -1;\r\n        this._freeRegionCount--;\r\n    }\r\n\r\n    private _rebucket(block: GaussianSplattingMemBlock): void {\r\n        const newBucket = this._bucketFor(block._size);\r\n        if (newBucket !== block._bucket) {\r\n            this._removeFromBucket(block);\r\n            this._addToBucket(block);\r\n        }\r\n    }\r\n\r\n    private _obtain(offset: number, size: number, free: boolean): GaussianSplattingMemBlock {\r\n        const block = this._pool.length > 0 ? this._pool.pop()! : new GaussianSplattingMemBlock();\r\n        block._offset = offset;\r\n        block._size = size;\r\n        block._free = free;\r\n        block._prev = null;\r\n        block._next = null;\r\n        block._prevFree = null;\r\n        block._nextFree = null;\r\n        block._bucket = -1;\r\n        return block;\r\n    }\r\n\r\n    private _release(block: GaussianSplattingMemBlock): void {\r\n        block._prev = null;\r\n        block._next = null;\r\n        block._prevFree = null;\r\n        block._nextFree = null;\r\n        block._bucket = -1;\r\n        this._pool.push(block);\r\n    }\r\n\r\n    private _insertAfterInMainList(block: GaussianSplattingMemBlock, after: Nullable<GaussianSplattingMemBlock>): void {\r\n        if (after === null) {\r\n            block._prev = null;\r\n            block._next = this._headAll;\r\n            if (this._headAll) {\r\n                this._headAll._prev = block;\r\n            }\r\n            this._headAll = block;\r\n            if (!this._tailAll) {\r\n                this._tailAll = block;\r\n            }\r\n        } else {\r\n            block._prev = after;\r\n            block._next = after._next;\r\n            if (after._next) {\r\n                after._next._prev = block;\r\n            }\r\n            after._next = block;\r\n            if (this._tailAll === after) {\r\n                this._tailAll = block;\r\n            }\r\n        }\r\n    }\r\n\r\n    private _removeFromMainList(block: GaussianSplattingMemBlock): void {\r\n        if (block._prev) {\r\n            block._prev._next = block._next;\r\n        } else {\r\n            this._headAll = block._next;\r\n        }\r\n        if (block._next) {\r\n            block._next._prev = block._prev;\r\n        } else {\r\n            this._tailAll = block._prev;\r\n        }\r\n        block._prev = null;\r\n        block._next = null;\r\n    }\r\n\r\n    private _findFreeBlock(size: number): Nullable<GaussianSplattingMemBlock> {\r\n        const startBucket = this._bucketFor(size);\r\n        const len = this._freeBucketHeads.length;\r\n\r\n        // Target bucket: best-fit (smallest block >= size).\r\n        if (startBucket < len) {\r\n            let best: Nullable<GaussianSplattingMemBlock> = null;\r\n            let node = this._freeBucketHeads[startBucket];\r\n            while (node) {\r\n                if (node._size >= size) {\r\n                    if (!best || node._size < best._size) {\r\n                        best = node;\r\n                        if (node._size === size) {\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n                node = node._nextFree;\r\n            }\r\n            if (best) {\r\n                return best;\r\n            }\r\n        }\r\n\r\n        // Higher buckets: first-fit (any block is large enough).\r\n        for (let b = startBucket + 1; b < len; b++) {\r\n            if (this._freeBucketHeads[b]) {\r\n                return this._freeBucketHeads[b];\r\n            }\r\n        }\r\n        return null;\r\n    }\r\n\r\n    private _defragFull(result: Set<GaussianSplattingMemBlock>): void {\r\n        // Remove all free blocks from all buckets and pool them.\r\n        for (let b = 0; b < this._freeBucketHeads.length; b++) {\r\n            let node = this._freeBucketHeads[b];\r\n            while (node) {\r\n                const nextFree = node._nextFree;\r\n                this._removeFromMainList(node);\r\n                node._prevFree = null;\r\n                node._nextFree = null;\r\n                node._bucket = -1;\r\n                this._pool.push(node);\r\n                node = nextFree;\r\n            }\r\n            this._freeBucketHeads[b] = null;\r\n        }\r\n        this._freeRegionCount = 0;\r\n\r\n        // Walk remaining (all allocated) blocks, assigning sequential offsets.\r\n        let offset = 0;\r\n        let block = this._headAll;\r\n        while (block) {\r\n            if (block._offset !== offset) {\r\n                block._offset = offset;\r\n                result.add(block);\r\n            }\r\n            offset += block._size;\r\n            block = block._next;\r\n        }\r\n\r\n        // Create a single free block at the end if there is remaining capacity.\r\n        const remaining = this._capacity - offset;\r\n        if (remaining > 0) {\r\n            const freeBlock = this._obtain(offset, remaining, true);\r\n            this._insertAfterInMainList(freeBlock, this._tailAll);\r\n            this._addToBucket(freeBlock);\r\n        }\r\n    }\r\n\r\n    private _defragIncremental(maxMoves: number, result: Set<GaussianSplattingMemBlock>): void {\r\n        const phase1Moves = Math.ceil(maxMoves / 2);\r\n        const phase2Moves = maxMoves - phase1Moves;\r\n\r\n        // Phase 1: relocate the last allocated block to the first fitting gap (maximizes tail free space).\r\n        for (let i = 0; i < phase1Moves; i++) {\r\n            let lastAlloc = this._tailAll;\r\n            while (lastAlloc && lastAlloc._free) {\r\n                lastAlloc = lastAlloc._prev;\r\n            }\r\n            if (!lastAlloc) {\r\n                break;\r\n            }\r\n\r\n            const gap = this._findFreeBlock(lastAlloc._size);\r\n            if (!gap || gap._offset >= lastAlloc._offset) {\r\n                break;\r\n            }\r\n\r\n            this._moveBlock(lastAlloc, gap);\r\n            result.add(lastAlloc);\r\n        }\r\n\r\n        // Phase 2: slide allocated blocks left into adjacent free gaps (cleans up interior fragmentation).\r\n        let block = this._headAll;\r\n        for (let i = 0; i < phase2Moves && block; ) {\r\n            const next = block._next;\r\n\r\n            if (block._free && next && !next._free) {\r\n                const allocBlock = next;\r\n                const freeBlock = block;\r\n\r\n                allocBlock._offset = freeBlock._offset;\r\n                freeBlock._offset = allocBlock._offset + allocBlock._size;\r\n\r\n                // Swap in the main list.\r\n                const a = freeBlock._prev;\r\n                const b = allocBlock._next;\r\n\r\n                allocBlock._prev = a;\r\n                allocBlock._next = freeBlock;\r\n                freeBlock._prev = allocBlock;\r\n                freeBlock._next = b;\r\n                if (a) {\r\n                    a._next = allocBlock;\r\n                } else {\r\n                    this._headAll = allocBlock;\r\n                }\r\n                if (b) {\r\n                    b._prev = freeBlock;\r\n                } else {\r\n                    this._tailAll = freeBlock;\r\n                }\r\n\r\n                // Merge the free block with its new right neighbor if also free.\r\n                if (freeBlock._next && freeBlock._next._free) {\r\n                    const right = freeBlock._next;\r\n                    freeBlock._size += right._size;\r\n                    this._removeFromMainList(right);\r\n                    this._removeFromBucket(right);\r\n                    this._release(right);\r\n                    this._rebucket(freeBlock);\r\n                }\r\n\r\n                result.add(allocBlock);\r\n                i++;\r\n\r\n                // Continue from the block after freeBlock to find more opportunities.\r\n                block = freeBlock._next;\r\n            } else {\r\n                block = next;\r\n            }\r\n        }\r\n    }\r\n\r\n    private _moveBlock(block: GaussianSplattingMemBlock, gap: GaussianSplattingMemBlock): void {\r\n        const blockSize = block._size;\r\n        const newOffset = gap._offset;\r\n\r\n        // 1. Remove the block from its current position, freeing that space.\r\n        const prev = block._prev;\r\n        this._removeFromMainList(block);\r\n\r\n        // Create a free region where the block was.\r\n        const freed = this._obtain(block._offset, blockSize, true);\r\n        this._insertAfterInMainList(freed, prev);\r\n        this._addToBucket(freed);\r\n\r\n        // Merge freed with its right neighbor.\r\n        if (freed._next && freed._next._free) {\r\n            const right = freed._next;\r\n            freed._size += right._size;\r\n            this._removeFromMainList(right);\r\n            this._removeFromBucket(right);\r\n            this._release(right);\r\n            this._rebucket(freed);\r\n        }\r\n        // Merge freed with its left neighbor.\r\n        if (freed._prev && freed._prev._free) {\r\n            const left = freed._prev;\r\n            left._size += freed._size;\r\n            this._removeFromMainList(freed);\r\n            this._removeFromBucket(freed);\r\n            this._release(freed);\r\n            this._rebucket(left);\r\n        }\r\n\r\n        // 2. Place the block at the gap.\r\n        block._offset = newOffset;\r\n\r\n        if (gap._size === blockSize) {\r\n            // Perfect fit: replace the gap with the block.\r\n            const gapPrev = gap._prev;\r\n            this._removeFromMainList(gap);\r\n            this._removeFromBucket(gap);\r\n            this._release(gap);\r\n            this._insertAfterInMainList(block, gapPrev);\r\n        } else {\r\n            // Partial fit: shrink the gap, insert the block before it.\r\n            gap._offset += blockSize;\r\n            gap._size -= blockSize;\r\n            this._rebucket(gap);\r\n            this._insertAfterInMainList(block, gap._prev);\r\n        }\r\n    }\r\n}\r\n"]}