@woosh/meep-engine 2.93.2 → 2.94.0

package/src/engine/graphics/texture/sampler/downloadSamplerAsPNG.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloadSamplerAsPNG.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/downloadSamplerAsPNG.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,kEAFW,MAAM,QAQhB"}
+{"version":3,"file":"downloadSamplerAsPNG.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/downloadSamplerAsPNG.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,uEAFW,MAAM,QAQhB"}

package/src/engine/graphics/texture/sampler/downloadSamplerAsPNG.js

@@ -4,12 +4,12 @@ import { convertSampler2D2DataURL } from "./convertSampler2D2DataURL.js";
 /**
  *
  * @param {Sampler2D} sampler
- * @param {string} [name]
+ * @param {string} [file_name] what should the file be named?
  */
-export function downloadSampler2DAsPNG(sampler, name = 'image') {
+export function downloadSampler2DAsPNG(sampler, file_name = 'image') {
 
     const dataURL = convertSampler2D2DataURL(sampler);
 
-    downloadUrlAsFile(dataURL, `${name}.png`);
+    downloadUrlAsFile(dataURL, `${file_name}.png`);
 
 }

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_blur_gaussian.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH,gDALW,SAAS,SACT,SAAS,QACT,MAAM,YACN,MAAM,QAqFhB;0BAxHyB,iBAAiB"}
+{"version":3,"file":"sampler2d_blur_gaussian.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,gDALW,SAAS,SACT,SAAS,QACT,MAAM,YACN,MAAM,QAoFhB;0BA9FyB,iBAAiB"}

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js

@@ -1,36 +1,11 @@
-import { gaussian } from "../../../../../core/math/gaussian.js";
-import { makeNextOdd } from "../../../../../core/math/makeNextOdd.js";
+import { build_gaussian_kernel_1d } from "../../../../../core/math/build_gaussian_kernel_1d.js";
 import { max2 } from "../../../../../core/math/max2.js";
+import { nextOdd } from "../../../../../core/math/nextOdd.js";
 import { Sampler2D } from "../Sampler2D.js";
 
 
 let temp_data = new Float64Array(1);
 
-/**
- *
- * @param {number} sample_count
- * @param {number} sigma
- * @param {Float32Array} kernel
- */
-function build_kernel(sample_count, sigma, kernel) {
-
-    const half_width = (sample_count - 1) * 0.5;
-
-    let kernel_power_sum = 0;
-    for (let i = 0; i < sample_count; i++) {
-        const local = i - half_width;
-
-        const power = gaussian(sigma, local);
-        kernel[i] = power;
-        kernel_power_sum += power;
-    }
-
-    // normalize kernel
-    for (let i = 0; i < sample_count; i++) {
-        kernel[i] /= kernel_power_sum;
-    }
-}
-
 /**
  *
  * @param {Sampler2D} output
@@ -41,11 +16,11 @@ function build_kernel(sample_count, sigma, kernel) {
 export function sampler2d_blur_gaussian(output, input, size, quality = 1) {
 
     const sigma = size * 3;
-    const sample_count = max2(3, makeNextOdd(Math.round(size * quality)));
+    const sample_count = max2(3, nextOdd(Math.round(size * quality)));
 
     const kernel = new Float32Array(sample_count);
 
-    build_kernel(sample_count, sigma, kernel);
+    build_gaussian_kernel_1d(kernel, sample_count, sigma);
 
     const width = input.width;
     const height = input.height;
@@ -53,6 +28,7 @@ export function sampler2d_blur_gaussian(output, input, size, quality = 1) {
 
     const total_value_count = width * height * channel_count;
     if (temp_data.length < total_value_count) {
+        // our static temp buffer is too small, let's make it larger
         temp_data = new Float64Array(total_value_count);
     }
 
@@ -93,8 +69,6 @@ export function sampler2d_blur_gaussian(output, input, size, quality = 1) {
     source = target;
     target = output;
 
-    // typed_array_copy(source.data, target.data);
-
     // vertical pass
     for (let y = 0; y < height; y++) {
         for (let x = 0; x < width; x++) {

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

@@ -1,10 +1,7 @@
 export class VirtualTextureMaterial extends ShaderMaterial {
-    /**
-     *
-     * @param {VirtualTexturePage} page
-     * @param {VirtualTextureMemoryMapping} mapping
-     */
-    constructor({ page, mapping }: VirtualTexturePage);
+    constructor({ uniforms }: {
+        uniforms: any;
+    });
 }
 import { ShaderMaterial } from "three";
 //# sourceMappingURL=VirtualTextureMaterial.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureMaterial.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureMaterial.js"],"names":[],"mappings":"AAEA;IACI;;;;OAIG;IACH,mDAuLC;CACJ;+BAhMmD,OAAO"}
+{"version":3,"file":"VirtualTextureMaterial.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureMaterial.js"],"names":[],"mappings":"AAEA;IACI;;OAyKC;CACJ;+BA7K0C,OAAO"}

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;