@woosh/meep-engine 3.22.0 → 3.23.0

package/src/shade/renderer/geometry/virtual/residency/VGeoResidencyOptions.d.ts

@@ -0,0 +1,49 @@
+/**
+ * What a {@link VGeoResidencyManager} is allowed to spend.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoResidencyOptions {
+    /**
+     * The RAM tier's budget: decoded page bytes, summed over every registered reader.
+     *
+     * Design §6 pins the tiers — CDN ⊇ RAM ⊇ VRAM — and says residency is a small fraction of the
+     * asset in RAM. What makes a number necessary rather than advisory is scale: a thousand assets
+     * of a hundred million triangles each are several gigabytes of pages *apiece*, so the resident
+     * set has to be a small fraction of *one* of them, and nothing about a single reader can know
+     * that. 512 MiB is a default to be overridden by whoever knows the device, not a measurement.
+     *
+     * It is spent against `VGeoContainerReader.resident_bytes`, which is decoded page images and
+     * not what those pages cost in the heap — the reader's own per-page bookkeeping measured
+     * 6.4–11.9 KB on top of each image, which is 1.2% at the page sizes design §5 targets. A budget
+     * set against unusually small pages should allow for it.
+     *
+     * @type {number}
+     */
+    budget_bytes: number;
+    /**
+     * How many page fetches may be in flight at once, across every registered reader.
+     *
+     * The number that matters to a browser and to a CDN, and the one no reader can set: eight
+     * readers at the per-reader default of 6 were measured issuing 48 concurrent range requests.
+     * Twelve is more than one HTTP/1.1 connection pool will give and less than an H2/H3 multiplex
+     * will happily carry, which is the range this wants to sit in.
+     *
+     * @type {number}
+     */
+    max_concurrent_fetches: number;
+    /**
+     * How many frames a page is protected from eviction after it was last touched.
+     *
+     * Design §6: eviction is LRU on **last-touched**, with a protect window no shorter than the
+     * feedback latency. The window is what stops the classic fallback-chain bug — feedback arrives a
+     * frame or three late, so a page that is on screen right now may not have been reported as
+     * touched yet, and evicting on a stamp that has not caught up evicts exactly what is being
+     * drawn. Three frames is one `mapAsync` round trip's worth of slack.
+     *
+     * @type {number}
+     */
+    protect_frames: number;
+}
+//# sourceMappingURL=VGeoResidencyOptions.d.ts.map

package/src/shade/renderer/geometry/virtual/residency/VGeoResidencyOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoResidencyOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/residency/VGeoResidencyOptions.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;;;;;;;;;;;;;;OAeG;IACH,cAFU,MAAM,CAEiB;IAEjC;;;;;;;;;OASG;IACH,wBAFU,MAAM,CAEY;IAE5B;;;;;;;;;;OAUG;IACH,gBAFU,MAAM,CAEG;CACtB"}

package/src/shade/renderer/geometry/virtual/residency/VGeoResidencyOptions.js

@@ -0,0 +1,50 @@
+/**
+ * What a {@link VGeoResidencyManager} is allowed to spend.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoResidencyOptions {
+    /**
+     * The RAM tier's budget: decoded page bytes, summed over every registered reader.
+     *
+     * Design §6 pins the tiers — CDN ⊇ RAM ⊇ VRAM — and says residency is a small fraction of the
+     * asset in RAM. What makes a number necessary rather than advisory is scale: a thousand assets
+     * of a hundred million triangles each are several gigabytes of pages *apiece*, so the resident
+     * set has to be a small fraction of *one* of them, and nothing about a single reader can know
+     * that. 512 MiB is a default to be overridden by whoever knows the device, not a measurement.
+     *
+     * It is spent against `VGeoContainerReader.resident_bytes`, which is decoded page images and
+     * not what those pages cost in the heap — the reader's own per-page bookkeeping measured
+     * 6.4–11.9 KB on top of each image, which is 1.2% at the page sizes design §5 targets. A budget
+     * set against unusually small pages should allow for it.
+     *
+     * @type {number}
+     */
+    budget_bytes = 512 * 1024 * 1024;
+
+    /**
+     * How many page fetches may be in flight at once, across every registered reader.
+     *
+     * The number that matters to a browser and to a CDN, and the one no reader can set: eight
+     * readers at the per-reader default of 6 were measured issuing 48 concurrent range requests.
+     * Twelve is more than one HTTP/1.1 connection pool will give and less than an H2/H3 multiplex
+     * will happily carry, which is the range this wants to sit in.
+     *
+     * @type {number}
+     */
+    max_concurrent_fetches = 12;
+
+    /**
+     * How many frames a page is protected from eviction after it was last touched.
+     *
+     * Design §6: eviction is LRU on **last-touched**, with a protect window no shorter than the
+     * feedback latency. The window is what stops the classic fallback-chain bug — feedback arrives a
+     * frame or three late, so a page that is on screen right now may not have been reported as
+     * touched yet, and evicting on a stamp that has not caught up evicts exactly what is being
+     * drawn. Three frames is one `mapAsync` round trip's worth of slack.
+     *
+     * @type {number}
+     */
+    protect_frames = 3;
+}

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#230@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#232@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#164@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#166@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/texture/bindless/GPUBindlessTextureManager.d.ts

@@ -3,6 +3,7 @@ export class GPUBindlessTextureManager {
         initial_size?: number;
         device: any;
     });
+    get buffer_data(): GPUBuffer;
     /**
      *
      * @param {number} slot_id
@@ -23,6 +24,8 @@ import { TextureDescriptor } from "../../../descriptor/texture/TextureDescriptor
 declare class GPUBindlessTexture {
     slot: number;
     /**
+     * Byte range inside {@link GPUBindlessTextureManager#buffer_data}. Handed out once and never
+     * revised — the manager makes room by appending to the arena, not by re-packing it.
      * @type {Allocation}
      */
     allocation: Allocation;

package/src/shade/renderer/texture/bindless/GPUBindlessTextureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUBindlessTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/bindless/GPUBindlessTextureManager.js"],"names":[],"mappings":"AA4BA;IAkBI;;;OAeC;IAcD;;;;;OAKG;IACH,aAJW,MAAM,UACN,iBAAiB,GACf,kBAAkB,CAwD9B;IAED;;;;;OAKG;IACH,wCAHW,kBAAkB,cAClB,MAAM,QAKhB;;CAGJ;kCAnJiC,kDAAkD;AAQpF;IACI,aAAS;IAET;;OAEG;IACH,uBAAU;IACV,8BAAqC;CACxC"}
+{"version":3,"file":"GPUBindlessTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/bindless/GPUBindlessTextureManager.js"],"names":[],"mappings":"AAsDA;IA0BI;;;OAuBC;IAhCD,6BAEC;IAmGD;;;;;OAKG;IACH,aAJW,MAAM,UACN,iBAAiB,GACf,kBAAkB,CA2D9B;IAED;;;;;OAKG;IACH,wCAHW,kBAAkB,cAClB,MAAM,QAKhB;;CAGJ;kCAvPiC,kDAAkD;AAgCpF;IACI,aAAS;IAET;;;;OAIG;IACH,uBAAU;IACV,8BAAqC;CACxC"}

package/src/shade/renderer/texture/bindless/GPUBindlessTextureManager.js

@@ -8,10 +8,36 @@ import { parse_gpu_texture_format } from "../../../descriptor/texture/format/par
 
 const DEFAULT_INITIAL_SIZE_BYTES = 1024;
 
+/**
+ * `copyBufferToBuffer` moves whole 4-byte units and the arena is enlarged by copying all of it, so
+ * every size this manager gives the device is a multiple of this.
+ * @type {number}
+ */
+const ARENA_GRANULARITY_BYTES = 4;
+
+/**
+ * How many times {@link GPUBindlessTextureManager#set} enlarges the arena for one texture before
+ * giving up. Growth is sized to fit the request that failed, so the retry after the first one is
+ * expected to be the last. The bound is here because an allocator out of nodes refuses a request of
+ * any size, and answering that with an unbounded loop would enlarge the buffer forever.
+ * @type {number}
+ */
+const MAX_GROWTH_ATTEMPTS_PER_TEXTURE = 2;
+
+/**
+ * @param {number} size in bytes
+ * @returns {number}
+ */
+function round_up_to_arena_granularity(size) {
+    return Math.ceil(size / ARENA_GRANULARITY_BYTES) * ARENA_GRANULARITY_BYTES;
+}
+
 class GPUBindlessTexture {
     slot = 0;
 
     /**
+     * Byte range inside {@link GPUBindlessTextureManager#buffer_data}. Handed out once and never
+     * revised — the manager makes room by appending to the arena, not by re-packing it.
      * @type {Allocation}
      */
     allocation
@@ -43,34 +69,105 @@ export class GPUBindlessTextureManager {
      */
     #data_buffer;
 
+    get buffer_data() {
+        return this.#data_buffer;
+    }
+
+    /**
+     * @type {GPUDevice}
+     */
+    #device;
 
     constructor({
                     initial_size = DEFAULT_INITIAL_SIZE_BYTES,
                     device
                 }) {
+        assert.defined(device, 'device');
+        assert.isNonNegativeInteger(initial_size, 'initial_size');
+        assert.greaterThan(initial_size, 0, 'initial_size');
+
+        const arena_size = round_up_to_arena_granularity(initial_size);
 
-        this.#allocator = new OffsetAllocator(initial_size);
+        this.#device = device;
+
+        this.#allocator = new OffsetAllocator(arena_size);
         this.#headers = new GPUSingleTypeTable({
             device,
             type: BINDLESS_TEXTURE_HEADER_STRUCT,
         });
 
         this.#data_buffer = device.createBuffer({
-            size: initial_size,
+            label: 'GPUBindlessTextureManager/data',
+            size: arena_size,
             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
         });
     }
 
-    #grow() {
-        throw new Error('Not implemented')
-    }
-
     /**
+     * Enlarge the data arena so that a `required_size` allocation has room, leaving every texture
+     * already in it exactly where it is.
      *
-     * @param {number} new_size
+     * Nothing relocates: a texture is addressed by the offset the allocator handed out,
+     * {@link OffsetAllocator#grow} appends the new tail as free space instead of re-packing, and the
+     * old bytes are copied into the larger buffer at offset 0 — so every live
+     * {@link GPUBindlessTexture#allocation} still names the bytes it named before the call, with no
+     * per-texture bookkeeping at all.
+     *
+     * Stops at the device's `maxBufferSize`, and does nothing at all once there. A texture that
+     * cannot be housed is then reported by the failed allocation in {@link set}.
+     *
+     * @param {number} required_size in bytes, the allocation that did not fit
      */
-    #resize(new_size) {
-        throw new Error('Not implemented')
+    #grow(required_size) {
+        assert.isNonNegativeInteger(required_size, 'required_size');
+
+        const device = this.#device;
+
+        const old_buffer = this.#data_buffer;
+        const old_size = old_buffer.size;
+
+        // The allocator bins free runs by rounding down and requests by rounding up, up to 9/8
+        // apart, so room for exactly `required_size` can still be refused — hence the headroom.
+        // Doubling on top of that keeps a run of small textures from paying for a copy of the whole
+        // arena apiece. The ceiling is the device's: `createBuffer` answers a size past
+        // `maxBufferSize` with an *invalid* buffer rather than an exception, and swapping one of
+        // those in would destroy the arena and leave the allocator sized for space that is not
+        // there, silently.
+        const new_size = Math.min(
+            round_up_to_arena_granularity(Math.max(
+                old_size * 2,
+                old_size + required_size * 9 / 8
+            )),
+            Math.floor(device.limits.maxBufferSize / ARENA_GRANULARITY_BYTES) * ARENA_GRANULARITY_BYTES
+        );
+
+        if (new_size <= old_size) {
+            // already as large as this device will allow
+            return;
+        }
+
+        const new_buffer = device.createBuffer({
+            label: old_buffer.label,
+            size: new_size,
+            usage: old_buffer.usage,
+        });
+
+        // past the fallible part — `OffsetAllocator#grow` cannot be undone
+        this.#allocator.grow(new_size);
+
+        const encoder = device.createCommandEncoder({
+            label: 'GPUBindlessTextureManager/grow',
+        });
+
+        // One copy of the whole old arena at offset 0. Offsets did not move, so the bytes land back
+        // under the addresses the textures holding them already have.
+        encoder.copyBufferToBuffer(old_buffer, 0, new_buffer, 0, old_size);
+
+        device.queue.submit([encoder.finish()]);
+
+        old_buffer.destroy();
+
+        this.#data_buffer = new_buffer;
     }
 
     /**
@@ -115,24 +212,27 @@ export class GPUBindlessTextureManager {
 
         const allocation_size = texel_count * attribute.getByteSize();
 
+        let allocation = this.#allocator.allocate(allocation_size);
 
-        while (true) {
-            // attempt allocation
-            const allocation = this.#allocator.allocate(allocation_size);
-
-            if (allocation.offset === ALLOCATOR_NO_SPACE) {
-                // try to enlarge the buffer
-                this.#grow();
-                continue;
-            }
+        for (
+            let attempt = 0;
+            allocation.offset === ALLOCATOR_NO_SPACE && attempt < MAX_GROWTH_ATTEMPTS_PER_TEXTURE;
+            attempt++
+        ) {
+            this.#grow(allocation_size);
 
-            texture.allocation = allocation;
+            allocation = this.#allocator.allocate(allocation_size);
+        }
 
-            break;
+        if (allocation.offset === ALLOCATOR_NO_SPACE) {
+            throw new Error(`Failed to allocate ${allocation_size} bytes for bindless texture in slot ${slot_id}`);
         }
 
+        texture.allocation = allocation;
+
         this.#headers.set(slot_id, {});
 
+        return texture;
     }
 
     /**
@@ -147,4 +247,4 @@ export class GPUBindlessTextureManager {
     }
 
 
-}
+}

package/src/shade/renderer/texture/virtual/README.md

@@ -6,10 +6,12 @@ textures, with GPU memory bounded by what is visible instead of what is
 loaded. Built for **hundreds of simultaneous virtual textures** sharing one
 page table, one physical cache and one feedback pass.
 
-This README covers adopting the system, configuration and the working
-design. The extended design document — literature survey,
-decision log, scale math, future work — is [`VIRTUAL_TEXTURES.md`](../../../../VIRTUAL_TEXTURES.md)
-in the repo root.
+This README is the design document: adopting the system, configuration and
+how it works. It used to defer the extended treatment — literature survey,
+decision log, scale math, future work — to a `VIRTUAL_TEXTURES.md` in the
+repo root, but that file belonged to the repository Shade was vendored from
+and never came across. The decision log is under "How it works" below; the
+scale numbers are in the configuration table.
 
 ---
 

package/src/shade/renderer/texture/virtual/VirtualTextureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,2EAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,uIAQC;IA8DD;;;;;;;OAOG;IACH,sBAHW,mBAAmB,GACjB,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,wBAFW,mBAAmB,QAgF7B;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eA2GC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK,EAAtB,UAAU;QACW,IAAI,EAAzB,cAAc;QACD,gBAAgB,EAA7B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACU,wBAAwB;aA6FlD;IAED,gBA8BC;;CACJ;yBAruCY,OAAO,8DAA8D,EAAE,UAAU;uCACjF,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;6BACtD,OAAO,8BAA8B,EAAE,cAAc;kCACrD,OAAO,0BAA0B,EAAE,mBAAmB;gCAPnC,sBAAsB"}
+{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,2EAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,uIAQC;IA8DD;;;;;;;OAOG;IACH,sBAHW,mBAAmB,GACjB,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,wBAFW,mBAAmB,QAgF7B;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eAkHC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK,EAAtB,UAAU;QACW,IAAI,EAAzB,cAAc;QACD,gBAAgB,EAA7B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACU,wBAAwB;aA6FlD;IAED,gBA8BC;;CACJ;yBA5uCY,OAAO,8DAA8D,EAAE,UAAU;uCACjF,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;6BACtD,OAAO,8BAA8B,EAAE,cAAc;kCACrD,OAAO,0BAA0B,EAAE,mBAAmB;gCAPnC,sBAAsB"}

package/src/shade/renderer/texture/virtual/VirtualTextureManager.js

@@ -1100,6 +1100,13 @@ export class VirtualTextureManager {
         }
 
         // 5. issue loads, coarse mips first (they unblock the most screen area)
+        //
+        //    Deliberately not a `core/process/ConcurrencyGate`. That gate orders by a priority
+        //    captured at submission and runs every closure it accepts. This order is not a
+        //    priority: coarse-first is the residency property that keeps the cache correct as it
+        //    fills, and it is re-derived from the live pending records here rather than fixed when
+        //    the request was made. Step 4 above then *drops* queued work that stopped being
+        //    touched, which a queue of closures has no way to express.
         if (this.#queue.length > 0 && this.#loads_in_flight < config.max_concurrent_loads) {
             this.#queue.sort((a, b) => {
                 const pa = this.#pending.get(a);

package/src/shade/renderer/texture/virtual/source/VTSourceTiled.d.ts

@@ -11,9 +11,9 @@
  * through the HTTP cache at memory speed).
  *
  * `legacy_meep_mips: true` maps mip indices to the original meep
- * virtual-texture converter's naming, where 0 is the *coarsest* level
- * (`${mip}-${x}-${y}.png`, see meep src/engine/graphics/texture/virtual):
- * pair it with url_template "{mip}-{x}-{y}.png" and per-layer base paths.
+ * virtual-texture converter's naming, where 0 is the *coarsest* level and
+ * tiles are written as `${mip}-${x}-${y}.png`: pair it with url_template
+ * "{mip}-{x}-{y}.png" and per-layer base paths.
  *
  * Decode notes: `colorSpaceConversion: 'none'` keeps browser colour
  * management from rewriting texels (tile seams, corrupted normal maps);

package/src/shade/renderer/texture/virtual/source/VTSourceTiled.js

@@ -13,9 +13,9 @@ import { assert } from "../../../../../core/assert.js";
  * through the HTTP cache at memory speed).
  *
  * `legacy_meep_mips: true` maps mip indices to the original meep
- * virtual-texture converter's naming, where 0 is the *coarsest* level
- * (`${mip}-${x}-${y}.png`, see meep src/engine/graphics/texture/virtual):
- * pair it with url_template "{mip}-{x}-{y}.png" and per-layer base paths.
+ * virtual-texture converter's naming, where 0 is the *coarsest* level and
+ * tiles are written as `${mip}-${x}-${y}.png`: pair it with url_template
+ * "{mip}-{x}-{y}.png" and per-layer base paths.
  *
  * Decode notes: `colorSpaceConversion: 'none'` keeps browser colour
  * management from rewriting texels (tile seams, corrupted normal maps);

package/src/engine/ecs/system/SystemExecutionPhase.d.ts

@@ -1,9 +0,0 @@
-/**
- * *
- */
-export type SystemExecutionPhase = number;
-export namespace SystemExecutionPhase {
-    let Simulation: number;
-    let PostPose: number;
-}
-//# sourceMappingURL=SystemExecutionPhase.d.ts.map

package/src/engine/ecs/system/SystemExecutionPhase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SystemExecutionPhase.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/SystemExecutionPhase.js"],"names":[],"mappings":";;;mCA2CU,MAAM;;oBASF,MAAM;kBAYN,MAAM"}

package/src/engine/graphics/texture/virtual/NOTES.md

@@ -1,128 +0,0 @@
-# Sparse Virtual Texture 
-
-This tech is based on popular Megatexture technique developed for Rage by John Carmack, working at id software.
-
-The key idea boils down to having a very large texture that is impractical to keep in memory, and only load and keep in memory pieces of it that are relevant to the current view.
-
-There are 2 parts to this technique, offline and online.
-
-## Offline
-
-The original texture is mip-mapped, down to the size of a single tile, for the sake of this document let it be 128x128 pixels. Each mip level is then cut into tiles and stored on disk. A good intuition for this is to think of each tile as a separate pixel, representing non-color data.
-
-## Online
-
-This is achieved by pre-rendering the scene with a special shader that records UV and mip-level information, which we call `Usage`, this is then analysed to build a list of used tiles (mip level, x, y) and by counting occurrence of this tile in the `Usage` texture we get a much more useful data structure.
-
-Based on the `Usage` data, we populate our `Physical` texture of pages, and based on what's currently in the `Physical` texture - we populate the `Reference` texture that stores information about the entire mip pyramid, and for each tile contains a pointer to the `Physical` texture, where representative tile can be found. 
-
-
-## Considerations
-
-
-### Filtering
-
-Most papers suggest introducing a border into each tile of ~4 pixels. 
-4 pixel border on a 128x128 pixel tile is going to take up 12.1% of space, which is quite a lot.
-We can do filtering in software, that is - sample individual pixels and perform interpolation inside the shader.
-
-### Speeding up WebGL read-back
-
-From [Babylon](https://github.com/BabylonJS/Babylon.js/blob/90dbafed8de9de752cdc399604f9c7c51116d630/src/Engines/engine.ts#L1772)
-```ts
-public _readPixelsAsync(x: number, y: number, w: number, h: number, format: number, type: number, outputBuffer: ArrayBufferView) {
-    if (this._webGLVersion < 2) {
-        throw new Error("_readPixelsAsync only work on WebGL2+");
-    }
-
-    let gl = <WebGL2RenderingContext>(this._gl as any);
-    const buf = gl.createBuffer();
-    gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);
-    gl.bufferData(gl.PIXEL_PACK_BUFFER, outputBuffer.byteLength, gl.STREAM_READ);
-    gl.readPixels(x, y, w, h, format, type, 0);
-    gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-
-    const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
-    if (!sync) {
-        return null;
-    }
-
-    gl.flush();
-
-    return this._clientWaitAsync(sync, 0, 10).then(() => {
-        gl.deleteSync(sync);
-
-        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);
-        gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, outputBuffer);
-        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-        gl.deleteBuffer(buf);
-
-        return outputBuffer;
-    });
-}
-    
-private _clientWaitAsync(sync: WebGLSync, flags = 0, intervalms = 10): Promise<void> {
-    const gl = <WebGL2RenderingContext>(this._gl as any);
-    return new Promise((resolve, reject) => {
-        const check = () => {
-            const res = gl.clientWaitSync(sync, flags, 0);
-            if (res == gl.WAIT_FAILED) {
-                reject();
-                return;
-            }
-            if (res == gl.TIMEOUT_EXPIRED) {
-                setTimeout(check, intervalms);
-                return;
-            }
-            resolve();
-        };
-
-        check();
-    });
-}
-```
-
-more links:
-https://forum.babylonjs.com/t/speeding-up-readpixels/12739
-
-
-## References
-
-* [Shadertoy: Anisotropic filtering in a shader](https://www.shadertoy.com/view/4lXfzn)
-* ["Adaptive Virtual Texture Rendering in Far Cry 4" by Ka Chen, Ubisoft. 2015](https://ubm-twvideo01.s3.amazonaws.com/o1/vault/gdc2015/presentations/Chen_Ka_AdaptiveVirtualTexture.pdf)
-* "id Tech 5 Challenges: From Texture Virtualization to Massive Parallelization" by J.M.P. van Waveren, id Software, SIGGRAPH 2009
-* "Using Virtual Texturing to Handle Massive Texture Data" by J.M.P. van Waveren, id Software, 2010
-* "Software Virtual Textures" by J.M.P. van Waveren, id Software, 2012
-* "Advanced Virtual Texture Topics" by Matrin Mittring, Crytek GmbH, SIGGRAPH 2008
-* "Atlas Shrugged: Device-agnostic Radiance Megatextures" by Mark Magro et al, University of Malta, VISIGRAPP 2020
-* ["Sparse virtual textures" by Nathan Gauër, 2022](https://studiopixl.com/2022-04-27/sparse-virtual-textures)
-* "Terrain in Battlefield 3: A modern, complete and scalable system" by Mattias Widmark, EA Digital Illusions (DICE), GDC 2012
-* "Virtual Texturing in Software and Hardware" by Juraj Obert (AMD) et al, SIGGRAPH 2012
-* "Virtual Texturing" by Albert Julian Mayer, 2010
-
-## WebGL fails
-
-WebGL doesn't seem to support mipmaps on integer textures
-
-## Anisotropic filtering:
-
-```glsl
-// R is viewport resolution
-// p is UV
-vec4 textureAniso(sampler2D T, vec2 R, vec2 p) {
-    mat2 J = inverse(mat2(dFdx(p),dFdy(p)));       // dFdxy: pixel footprint in texture space
-    J = transpose(J)*J;                            // quadratic form
-    float d = determinant(J), t = J[0][0]+J[1][1], // find ellipse: eigenvalues, max eigenvector
-          D = sqrt(abs(t*t-4.*d)),                 // abs() fix a bug: in weird view angles 0 can be slightly negative
-          V = (t-D)/2., v = (t+D)/2.,                     // eigenvalues. ( ATTENTION: not sorted )
-          M = 1./sqrt(V), m = 1./sqrt(v), l =log2(m*R.y); // = 1./radii^2
-          
-    //if (M/m>16.) l = log2(M/16.*R.y);                     // optional
-    
-    vec2 A = M * normalize(vec2( -J[0][1] , J[0][0]-V )); // max eigenvector = main axis
-    vec4 O = vec4(0);
-    for (float i = -7.5; i<8.; i++)                       // sample x16 along main axis at LOD min-radius
-        O += textureLod(T, p+(i/16.)*A, l);
-    return O/16.;
-}
-```

package/src/engine/graphics/texture/virtual/VT_DEFAULT_PAGE_RESOLUTION.d.ts

@@ -1,6 +0,0 @@
-/**
- * Default resolution of virtual page texture
- * @type {number}
- */
-export const VT_DEFAULT_PAGE_RESOLUTION: number;
-//# sourceMappingURL=VT_DEFAULT_PAGE_RESOLUTION.d.ts.map

package/src/engine/graphics/texture/virtual/VT_DEFAULT_PAGE_RESOLUTION.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VT_DEFAULT_PAGE_RESOLUTION.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VT_DEFAULT_PAGE_RESOLUTION.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,yCAFU,MAAM,CAE+B"}

package/src/engine/graphics/texture/virtual/VT_DEFAULT_PAGE_RESOLUTION.js

@@ -1,5 +0,0 @@
-/**
- * Default resolution of virtual page texture
- * @type {number}
- */
-export const VT_DEFAULT_PAGE_RESOLUTION = 4096;

package/src/engine/graphics/texture/virtual/VirtualTextureTileLoader.d.ts

@@ -1,49 +0,0 @@
-/**
- * Facilitates prioritized queueing and loading of individual texture tiles
- */
-export class VirtualTextureTileLoader {
-    /**
-     *
-     * @param {(mip: number, x: number, y: number) => string} builder
-     */
-    set file_name_builder(builder: (arg0: number, arg1: number, arg2: number) => string);
-    /**
-     *
-     * @return {function(number, number, number): string}
-     */
-    get file_name_builder(): (arg0: number, arg1: number, arg2: number) => string;
-    set path(v: any);
-    /**
-     * When queue gets larger than this, we start discarding elements
-     * @type {number}
-     */
-    queue_limit: number;
-    set asset_manager(v: any);
-    /**
-     * @readonly
-     */
-    readonly on: {
-        /**
-         * @type {Signal<VirtualTextureTile>}
-         */
-        loaded: any;
-    };
-    /**
-     *
-     * @param {number} fingerprint
-     */
-    enqueue(fingerprint: number): boolean;
-    /**
-     *
-     * @param {number} fingerprint
-     * @returns {boolean}
-     */
-    is_queued(fingerprint: number): boolean;
-    /**
-     *
-     * @param {VirtualTextureUsage} usage
-     */
-    update_usage(usage: VirtualTextureUsage): void;
-    #private;
-}
-//# sourceMappingURL=VirtualTextureTileLoader.d.ts.map

package/src/engine/graphics/texture/virtual/VirtualTextureTileLoader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VirtualTextureTileLoader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureTileLoader.js"],"names":[],"mappings":"AAYA;;GAEG;AACH;IA6BI;;;OAGG;IACH,sCAVqB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,MAAM,EAcnD;IAhBD;;;OAGG;IACH,gCAFqB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,MAAM,CAInD;IAYD,iBAEC;IAED;;;OAGG;IACH,aAFU,MAAM,CAEO;IAQvB,0BAEC;IAsBD;;OAEG;IACH;QACI;;WAEG;;MAEL;IAkCF;;;OAGG;IACH,qBAFW,MAAM,WAchB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,OAAO,CAMnB;IAsBD;;;OAGG;IACH,+CASC;;CAiEJ"}