@woosh/meep-engine 2.93.3 → 2.94.0

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

@@ -1,32 +1,12 @@
-import { DoubleSide, ShaderMaterial, Vector2 } from "three";
+import { DoubleSide, ShaderMaterial } from "three";
 
 export class VirtualTextureMaterial extends ShaderMaterial {
-    /**
-     *
-     * @param {VirtualTexturePage} page
-     * @param {VirtualTextureMemoryMapping} mapping
-     */
     constructor({
-                    page,
-                    mapping
+                    uniforms
                 }) {
         super({
             side: DoubleSide,
-            uniforms: {
-                u_page: { value: page.texture },
-                u_page_resolution: {
-                    value: new Vector2(
-                        page.page_texture_resolution_in_tiles[0],
-                        page.page_texture_resolution_in_tiles[1]
-                    )
-                },
-                u_tile_resolution: { value: page.tile_resolution },
-                u_tile_padding: { value: page.tile_margin },
-                u_mapping: { value: mapping.texture },
-                u_texture_resolution: { value: mapping.resolution * page.tile_resolution },
-                u_max_mip_level: { value: mapping.max_mip_level },
-                u_mapping_texture_width: { value: mapping.texture.image.width }
-            },
+            uniforms,
             vertexShader: `
         
     // uniform mat4 modelViewMatrix;
@@ -130,7 +110,7 @@ export class VirtualTextureMaterial extends ShaderMaterial {
         return vec2(tp00) + tile_uv;
     }
     
-    vec4 VirtualFetchLod(const in vec2 uv,const in uint texture_lod_0){
+    vec4 VirtualFetchLod(const in vec2 uv, const in uint texture_lod_0){
         uint ui_texture_lod_0 = u_max_mip_level - texture_lod_0;
         uint tile_mip_size = 1u << ui_texture_lod_0;
                 
@@ -144,10 +124,9 @@ export class VirtualTextureMaterial extends ShaderMaterial {
         float f_tile_resolution = float(u_tile_resolution);
         float slot_size = float(u_tile_resolution + u_tile_padding*2u);
         
-        ivec2 texture_size = textureSize(u_page,0);        
+        ivec2 texture_size = textureSize(u_page, 0);        
         
-        vec2 texel = tile_offset * slot_size + float(u_tile_padding)  + tile_uv*(f_tile_resolution) ;
-        // vec2 texel = tile_offset * slot_size + float(u_tile_padding)  + tile_uv*(f_tile_resolution) - 0.5;
+        vec2 texel = tile_offset * slot_size + float(u_tile_padding)  + tile_uv*(f_tile_resolution);
        
         vec2 page_uv =  texel / vec2(texture_size);
         
@@ -179,6 +158,8 @@ export class VirtualTextureMaterial extends ShaderMaterial {
         
         // return texelFetch( u_page, tuv, 0 );
        
+       // return VirtualFetchLod(uv, 7u);
+       // return vec4(uv, texture_lod / 7.0,1.0);
     }
     
     void main(){    

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

@@ -15,6 +15,10 @@ export class VirtualTextureMemoryMapping {
      * @param {VirtualTexturePage} page
      */
     set residency(arg: VirtualTexturePage);
+    getTileMetadata(x: any, y: any, mip: any): {
+        slot: number;
+        mip: number;
+    };
     dispose(): void;
     #private;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureMemoryMapping.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureMemoryMapping.js"],"names":[],"mappings":"AAcA;;GAEG;AACH;IAQI,4BAEC;IAWD,2BAEC;IAeD;;;OAGG;IACH,4BAiCC;IAED,yBAEC;IAED;;;OAGG;IACH,uCAsEC;IAGD,gBAEC;;CACJ;4BAlLkG,OAAO"}
+{"version":3,"file":"VirtualTextureMemoryMapping.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureMemoryMapping.js"],"names":[],"mappings":"AAcA;;GAEG;AACH;IAQI,4BAEC;IAWD,2BAEC;IAeD;;;OAGG;IACH,4BAiCC;IAED,yBAEC;IAED;;;OAGG;IACH,uCAsEC;IAED;;;MAUC;IAGD,gBAEC;;CACJ;4BA9LkG,OAAO"}

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

@@ -172,6 +172,18 @@ export class VirtualTextureMemoryMapping {
         this.#texture.needsUpdate = true;
     }
 
+    getTileMetadata(x,y,mip){
+
+        const tile_address = compose_tile_address(mip, x, y);
+
+        const encoded_tile = this.#pyramid[tile_address];
+
+        return {
+            slot: encoded_tile & 0x3FFFFF,
+            mip: ((encoded_tile >> 22) & 0x3FF)
+        };
+    }
+
 
     dispose() {
         this.#texture.dispose();

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

@@ -0,0 +1,29 @@
+export class VirtualTextureSystem {
+    updater: VirtualTextureUsageUpdater;
+    page: VirtualTexturePage;
+    mapping: VirtualTextureMemoryMapping;
+    setTexture({ path, texture_resolution, tile_resolution, tile_margin, }: {
+        path: any;
+        texture_resolution: any;
+        tile_resolution: any;
+        tile_margin: any;
+    }): void;
+    initialize({ page_resolution, asset_manager }: {
+        page_resolution?: number;
+        asset_manager: any;
+    }): void;
+    makeMaterial(): VirtualTextureMaterial;
+    /**
+     *
+     * @param {WebGLRenderer} renderer
+     * @param {Scene} scene
+     * @param {Camera} camera
+     */
+    update(renderer: WebGLRenderer, scene: Scene, camera: Camera): void;
+    #private;
+}
+import { VirtualTextureUsageUpdater } from "./VirtualTextureUsageUpdater.js";
+import { VirtualTexturePage } from "./VirtualTexturePage.js";
+import { VirtualTextureMemoryMapping } from "./VirtualTextureMemoryMapping.js";
+import { VirtualTextureMaterial } from "./VirtualTextureMaterial.js";
+//# sourceMappingURL=VirtualTextureSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualTextureSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureSystem.js"],"names":[],"mappings":"AAMA;IACI,oCAA0C;IAC1C,yBAA+B;IAC/B,qCAA2C;IAgB3C;;;;;aAeC;IAsBD;;;aAWC;IAED,uCAIC;IAED;;;;;OAKG;IACH,oEAaC;;CACJ;2CAjG0C,iCAAiC;mCADzC,yBAAyB;4CADhB,kCAAkC;uCADvC,6BAA6B"}

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

@@ -0,0 +1,102 @@
+import { Vector2 } from "three";
+import { VirtualTextureMaterial } from "./VirtualTextureMaterial.js";
+import { VirtualTextureMemoryMapping } from "./VirtualTextureMemoryMapping.js";
+import { VirtualTexturePage } from "./VirtualTexturePage.js";
+import { VirtualTextureUsageUpdater } from "./VirtualTextureUsageUpdater.js";
+
+export class VirtualTextureSystem {
+    updater = new VirtualTextureUsageUpdater()
+    page = new VirtualTexturePage()
+    mapping = new VirtualTextureMemoryMapping()
+
+    #managed_materials_uniforms = {
+
+        u_page: { value: null },
+        u_page_resolution: {
+            value: new Vector2(0, 0)
+        },
+        u_tile_resolution: { value: 1 },
+        u_tile_padding: { value: 0 },
+        u_mapping: { value: null },
+        u_texture_resolution: { value: 0 },
+        u_max_mip_level: { value: 0 },
+        u_mapping_texture_width: { value: 0 }
+    };
+
+    setTexture({
+                   path,
+                   texture_resolution,
+                   tile_resolution,
+                   tile_margin,
+               }) {
+        this.updater.setTextureParameters(
+            texture_resolution,
+            tile_resolution,
+            3
+        );
+        this.page.tile_resolution = this.updater.tile_resolution;
+        this.page.path = path;
+
+        this.mapping.resolution = this.updater.texture_resolution / this.updater.tile_resolution;
+    }
+
+    #updateUniforms() {
+        const uniforms = this.#managed_materials_uniforms;
+
+
+        const page = this.page;
+        const mapping = this.mapping;
+
+        uniforms.u_page.value = page.texture;
+        uniforms.u_page_resolution.value.set(
+            page.page_texture_resolution_in_tiles[0],
+            page.page_texture_resolution_in_tiles[1]
+        );
+        uniforms.u_tile_resolution.value = page.tile_resolution;
+        uniforms.u_tile_padding.value = page.tile_margin;
+        uniforms.u_mapping.value = mapping.texture;
+        uniforms.u_texture_resolution.value = mapping.resolution * page.tile_resolution;
+        uniforms.u_max_mip_level.value = mapping.max_mip_level;
+        uniforms.u_mapping_texture_width.value = mapping.texture.image.width;
+    }
+
+    initialize({
+                   page_resolution = 2048,
+                   asset_manager
+               }) {
+
+
+        this.page.page_texture_size = [page_resolution, page_resolution];
+        this.page.asset_manager = asset_manager;
+        // this.page.tile_margin = tile_margin;
+
+
+    }
+
+    makeMaterial() {
+        return new VirtualTextureMaterial({
+            uniforms: this.#managed_materials_uniforms
+        });
+    }
+
+    /**
+     *
+     * @param {WebGLRenderer} renderer
+     * @param {Scene} scene
+     * @param {Camera} camera
+     */
+    update(renderer, scene, camera) {
+        this.page.renderer = renderer;
+
+        const view_port_size = renderer.getSize(new Vector2());
+        view_port_size.multiplyScalar(renderer.getPixelRatio());
+
+        this.updater.setViewportResolution(view_port_size.x, view_port_size.y);
+        this.updater.updateUsage(renderer, scene, camera);
+        this.page.update_usage(this.updater.usage_metadata);
+        this.mapping.residency = this.page;
+
+        //
+        this.#updateUniforms();
+    }
+}

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

@@ -83,7 +83,7 @@ export class VirtualTextureUsageUpdater {
      */
     #frame_jitter_offsets = new Float32Array([0, 0]);
     #frame_jitter_samples = 1;
-    #frame_jitter_enabled = true;
+    #frame_jitter_enabled = false;
 
     get frame_jitter_enabled() {
         return this.#frame_jitter_enabled;

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

@@ -7,21 +7,22 @@ import {
     PerspectiveCamera,
     PlaneBufferGeometry,
     Scene,
-    Vector2,
     WebGLRenderer
 } from "three";
 import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import "../../../../../../../../css/main.scss";
 import Signal from "../../../../core/events/signal/Signal.js";
+import { computePathDirectory } from "../../../../core/path/computePathDirectory.js";
+import LabelView from "../../../../view/common/LabelView.js";
 import { CSS_ABSOLUTE_POSITIONING } from "../../../../view/CSS_ABSOLUTE_POSITIONING.js";
 import EmptyView from "../../../../view/elements/EmptyView.js";
+import SmoothProgressBar from "../../../../view/elements/progress/SmoothProgressBar.js";
 import { AssetManager } from "../../../asset/AssetManager.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { buildCanvasViewFromTexture } from "../../render/visibility/hiz/buildCanvasViewFromTexture.js";
-import { VirtualTextureMaterial } from "./VirtualTextureMaterial.js";
-import { VirtualTextureMemoryMapping } from "./VirtualTextureMemoryMapping.js";
-import { VirtualTexturePage } from "./VirtualTexturePage.js";
-import { VirtualTextureUsageUpdater } from "./VirtualTextureUsageUpdater.js";
+import { VirtualTextureSystem } from "./VirtualTextureSystem.js";
 
 let camera,
     /**
@@ -45,18 +46,13 @@ const signal_render = new Signal();
 // const TEXTURE_URL = "data/textures/utility/TESTIMAGES/SAMPLING/8BIT/RGB/2448x2448/SRC/img_2448x2448_3x8bit_SRC_RGB_cards_a.png";
 // const TEXTURE_URL = "data/models/LowPolyTownshipSet/Town_Hall//diffuse_2048.png";
 
-const virtualTextureManager = new VirtualTextureUsageUpdater();
-const virtualTexturePage = new VirtualTexturePage();
-// const residencyDebugView = new ResidencyDebugView({ scale: 1 });
-const memoryMapping = new VirtualTextureMemoryMapping();
-
 
 // const usageDebugView = new UsageDebugView();
 // usageDebugView.position.set(0,256);
-
-window.page = virtualTexturePage;
-window.mapping = memoryMapping;
-window.usage = virtualTextureManager.usage_metadata;
+//
+// window.page = virtualTexturePage;
+// window.mapping = memoryMapping;
+// window.usage = virtualTextureManager.usage_metadata;
 
 const container_view = new EmptyView();
 
@@ -95,25 +91,125 @@ function makeMesh(mat) {
     return mesh;
 }
 
-async function init() {
+/**
+ *
+ * @type {VirtualTextureSystem[]}
+ */
+const virtual_texture_managers = [];
 
-    const am = new AssetManager();
-    await am.registerLoader(GameAssetType.Image, new ImageRGBADataLoader());
-    am.startup();
+async function loadGLTF({
+                            path
+                        }) {
 
-    virtualTextureManager.setTextureParameters(
-        // 32768,
-        // 16384,
-        // 8192,
-        // 2048,
-        // 16384,
-        512,
-        32,
-        // 128,
-        3
-    );
+    const loader = new GLTFLoader();
+
+    const base_path = computePathDirectory(path);
+
+    const progress = new SmoothProgressBar();
+
+    function layout() {
+        progress.size.set(100, 20);
+        progress.position.set((container_view.size.x - progress.size.x) * 0.5, (container_view.size.y - progress.size.y) * 0.5);
+    }
+
+    layout();
+    container_view.size.onChanged.add(layout);
+
+    container_view.addChild(progress);
+
+    const gltf = await new Promise((resolve, reject) => {
+
+        loader.load(path, resolve, event => {
+            console.log(event);
+
+            progress.max = event.total;
+            progress.value = event.loaded;
+        }, reject);
+    })
+
+    container_view.removeChild(progress);
+
+
+    console.warn(gltf);
+
+    const materials = new Set();
+
+    /**
+     *
+     * @type {Map<Material, Mesh[]>}
+     */
+    const material_users = new Map();
+
+    /**
+     *
+     * @type {Map<Material, Material>}
+     */
+    const replacement_materials = new Map();
+
+    gltf.scene.traverse(n => {
+        if (!n.isMesh) {
+            return;
+        }
+
+        const mat = n.material;
+        if (mat === undefined) {
+            return;
+        }
+
+        if (materials.has(mat)) {
+            return;
+        }
+
+        const extensionVT = mat.userData?.gltfExtensions?.meepVirtualTexture;
+        if (extensionVT === undefined) {
+            return;
+        }
+
+        materials.add(mat);
+
+        const vts = {};
+
+        for (const textureKey in extensionVT) {
+            const textureMeta = extensionVT[textureKey];
+
+            const vt = new VirtualTextureSystem();
+
+            vt.setTexture({
+                path: base_path + '/' + textureMeta.path,
+                texture_resolution: textureMeta.texture_resolution,
+                tile_resolution: textureMeta.tile_size,
+                tile_margin: textureMeta.tile_margin
+            });
+
+            virtual_texture_managers.push(vt);
+
+            vts[textureKey] = vt;
+        }
 
-    virtualTexturePage.tile_resolution = virtualTextureManager.tile_resolution;
+        if (vts.baseColorTexture !== undefined) {
+            replacement_materials.set(mat, vts.baseColorTexture.makeMaterial())
+        }
+    })
+
+    // replace materials
+    gltf.scene.traverse(n => {
+        if (n.isMesh) {
+
+            const replacement = replacement_materials.get(n.material);
+
+            if (replacement !== undefined) {
+                n.material = replacement;
+            }
+
+        }
+    });
+
+    return gltf.scene;
+}
+
+function flatSample({
+                        am
+                    }) {
 
     // virtualTexturePage.path = "data/textures/utility/maurus_uv_checker_8k/vt-01-32";
     // virtualTexturePage.path = "data/textures/utility/maurus_uv_checker_8k/vt-01-128";
@@ -121,25 +217,63 @@ async function init() {
     // virtualTexturePage.path = "data/textures/utility/aco-greece/vt-01-128";
     // sparseTexture.path = "data/textures/utility/vt/uv_map_reference";
     // virtualTexturePage.path = "data/textures/utility/vt/Lenna";
-    virtualTexturePage.path = "data/textures/utility/Lenna/vt-01-32";
+    // virtualTexturePage.path = "data/textures/utility/Lenna/vt-01-32";
     // sparseTexture.path = "data/textures/utility/vt/TexelDensity1";
-    // virtualTexturePage.page_texture_size = [32, 64];
-    // virtualTexturePage.page_texture_size = [256, 256];
-    // virtualTexturePage.page_texture_size = [280, 280];
-    // virtualTexturePage.page_texture_size = [256,512];
-    virtualTexturePage.page_texture_size = [512, 512];
-    // virtualTexturePage.page_texture_size = [480, 480];
-    // virtualTexturePage.page_texture_size = [384, 1280];
-    // virtualTexturePage.page_texture_size = [1024, 1024];
-    // virtualTexturePage.page_texture_size = [2048, 2048];
-    // virtualTexturePage.page_texture_size = [4096, 4096];
-    virtualTexturePage.asset_manager = am;
 
-    memoryMapping.resolution = virtualTextureManager.texture_resolution / virtualTextureManager.tile_resolution;
+    const vts = new VirtualTextureSystem();
+
+    vts.setTexture({
+        path: "data/textures/utility/Lenna/vt-01-32",
+        texture_resolution: 512,
+        tile_resolution: 32,
+    });
+    vts.initialize({
+        asset_manager: am,
+        // page_resolution: 1024
+    })
+    // console.log(virtualTexturePage);
+
+    const material = vts.makeMaterial();
 
+    console.log(material.uniforms);
+
+    const virt = makeMesh(material);
+
+
+    virtual_texture_managers.push(vts);
+
+}
+
+async function init() {
+
+    const am = new AssetManager();
+    await am.registerLoader(GameAssetType.Image, new ImageRGBADataLoader());
+    am.startup();
+
+    const container = document.body;
+
+    container.style.margin = "0";
+
+    container.appendChild(container_view.el);
+    container_view.link();
+
+    scene = new Scene();
+
+    const gltf = await loadGLTF({ path: "data/models/Scans/green_car_wreck/converted/model.gltf" })
+
+
+    virtual_texture_managers.forEach(vt => {
+        vt.initialize({
+            asset_manager: am,
+            page_resolution: 4096
+        })
+    });
 
-    console.log(virtualTexturePage);
+    console.log(virtual_texture_managers);
 
+    const manager = virtual_texture_managers[0];
+
+    scene.add(gltf);
 
     //
     // usageDebugView.mip_levels = virtualTextureManager.max_mip_level;
@@ -147,29 +281,41 @@ async function init() {
 
 
     // const usagePyramidDebugView = new UsagePyramidDebugView();
-    // usagePyramidDebugView.setImageURL(TEXTURE_URL);
+    // usagePyramidDebugView.setImageURL("data/models/Scans/green_car_wreck/converted/merged_1024.png");
     // container_view.addChild(usagePyramidDebugView);
+    //
+    // signal_render.add(()=>{
+    //
+    //     usagePyramidDebugView.setTextureParameters(manager.updater.texture_resolution, manager.updater.tile_resolution);
+    //     usagePyramidDebugView.usage = manager.updater.usage_metadata;
+    // })
 
-    // residencyDebugView.texture = virtualTexturePage;
+    // const residencyDebugView = new ResidencyDebugView();
+    // residencyDebugView.texture = manager.page;
     // residencyDebugView.css({
     //     bottom: 0,
     //     right: 0
     // });
     // container_view.addChild(residencyDebugView);
+    //
+    // signal_render.add(()=> residencyDebugView.update());
 
     // ===================
 
-    const container = document.body;
-
-    container.style.margin = "0";
-
-    container.appendChild(container_view.el);
-    container_view.link();
 
     camera = new PerspectiveCamera(35, window.innerWidth / window.innerHeight, 0.1, 100);
-    camera.position.z = 30;
+    camera.position.set(
+        12.022084899129627,
+        9.60952583639588,
+        -0.04984304693423923
+    );
+    camera.rotation.set(
+        -1.5687013871667483,
+        0.9201500864954011,
+        1.5681634783563936);
+
+    window.camera = camera;
 
-    scene = new Scene();
     // scene.background = new Color("#002D62");
 
     clock = new Clock();
@@ -183,15 +329,8 @@ async function init() {
     //     side: DoubleSide
     // });
 
-    const material = new VirtualTextureMaterial({
-        page: virtualTexturePage,
-        mapping: memoryMapping
-    })
-
-    console.log(material.uniforms);
 
     // makeTorus();
-    const virt = makeMesh(material);
     // virt.position.x = -0.4
 
     // const original_texture = new TextureLoader().load("data/textures/utility/maurus_uv_checker_8k/UV-CheckerMap_Maurus_01_8K.png");
@@ -216,7 +355,7 @@ async function init() {
     //
 
     renderer = new WebGLRenderer({ antialias: true });
-    renderer.setClearColor("#002D62",1);
+    renderer.setClearColor("#002D62", 1);
 
     renderer.setPixelRatio(window.devicePixelRatio);
     container.appendChild(renderer.domElement);
@@ -242,13 +381,12 @@ async function init() {
     //     gui.add(options, key);
     // });
 
-    virtualTexturePage.renderer = renderer;
-
 
     animate();
 
+
     const mappingPreview = buildCanvasViewFromTexture({
-        texture: virtualTexturePage.texture,
+        texture: manager.page.texture,
         renderer,
         swizzle: ['r', 'g', 'b', 1],
         width: 256,
@@ -259,15 +397,29 @@ async function init() {
     mappingPreview.view.css(CSS_ABSOLUTE_POSITIONING);
     mappingPreview.view.css({
         // border: "1px solid red"
-        boxShadow: "0 0 8px rgba(0,0,0,0.4)"
+        boxShadow: "0 0 8px rgba(0,0,0,0.4)",
     });
-    mappingPreview.view.position.set(0, 0);
+    mappingPreview.view.position.set(4, 4);
+
 
     signal_render.add(() => {
         mappingPreview.render();
     });
 
     container_view.addChild(mappingPreview.view);
+
+    // credits
+    container_view.addChild(new LabelView(`MODEL: Green car wreck, by matousekfoto, CC-BY-4.0`, {
+        css: {
+            position: "absolute",
+            bottom: "4px",
+            width: "100%",
+            textAlign: "center",
+            color: "#88e1d2",
+            textShadow: "0 0 3px black",
+            fontFamily: "monospace"
+        }
+    }));
 }
 
 function onWindowResize() {
@@ -292,20 +444,13 @@ function animate() {
 function render() {
 
     const delta = 5 * clock.getDelta();
-    //
+
     // if (options.spin && mesh !== undefined) {
     //     mesh.rotation.y += 0.0125 * delta;
     //     mesh.rotation.x += 0.05 * delta;
     // }
 
-    const view_port_size = renderer.getSize(new Vector2());
-    view_port_size.multiplyScalar(renderer.getPixelRatio());
-
-
-    virtualTextureManager.setViewportResolution(view_port_size.x, view_port_size.y);
-    virtualTextureManager.updateUsage(renderer, scene, camera);
-    virtualTexturePage.update_usage(virtualTextureManager.usage_metadata);
-    memoryMapping.residency = virtualTexturePage;
+    virtual_texture_managers.forEach(vts => vts.update(renderer, scene, camera));
 
     // renderer.setViewport(0, 0, view_port_size.x, view_port_size.y);
     renderer.clear();
@@ -313,9 +458,6 @@ function render() {
 
     // usageDebugView.usage = virtualTextureManager.usage_metadata;
 
-    // usagePyramidDebugView.setTextureParameters(virtualTextureManager.texture_resolution, virtualTextureManager.tile_resolution);
-    // usagePyramidDebugView.usage = virtualTextureManager.usage_metadata;
-
     // residencyDebugView.update();
 
     signal_render.send0();

package/src/generation/filtering/numeric/CellFilterCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAIA;IAeI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAU3B;IA3BD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;CAyDb;yCA1EwC,qCAAqC"}
+{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAIA;IAeI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAU3B;IA3BD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;CAyDb;yCAxEwC,qCAAqC"}