@woosh/meep-engine 2.33.4 → 2.33.9

package/engine/graphics/render/visibility/hiz/query/QueryShader.js

@@ -0,0 +1,173 @@
+import { GLSL3, ShaderMaterial, Vector2 } from "three";
+
+export function makeQueryShader() {
+    return new ShaderMaterial({
+        vertexShader: `
+            void main() {
+                gl_Position = vec4( position, 1.0 );
+            }
+        `,
+        fragmentShader: `
+            uniform sampler2D utDepth;
+            uniform sampler2D utInput;
+            
+            uniform vec2 uDepthMipLimits;
+            
+            out highp vec4 out_value;
+            
+            float reduce(float a, float b, float c, float d){
+                return max( a, max( b, max( c, d ) ) );
+            }
+            
+            vec3 read_input_v3(ivec2 start){
+                float x = texelFetch(utInput, start, 0).x;
+                float y = texelFetch(utInput, start + ivec2(1,0), 0).x;
+                float z = texelFetch(utInput, start + ivec2(2,0), 0).x;
+            
+                return vec3(x,y,z);
+            }
+            
+            vec4 read_input_v4(ivec2 start){
+                return vec4(
+                    read_input_v3(start),
+                    texelFetch(utInput, start + ivec2(3,0) , 0).x
+                );
+            }
+            
+            mat4 read_input_m4(ivec2 start){
+                return mat4(
+                    read_input_v4(start),
+                    read_input_v4(start + ivec2(4,0)),
+                    read_input_v4(start + ivec2(8,0)),
+                    read_input_v4(start + ivec2(12,0))
+                );
+            }
+            
+            vec3 project_vec3(vec3 value, mat4 transform){
+                vec4 v1 = transform * vec4( value, 1.0 );
+                v1.xyz /= abs(v1.w);
+                
+                return v1.xyz;
+            }
+            
+            void project_aabb(out vec3 pb_min, out vec3 pb_max, in vec3 bb_min, in vec3 bb_max, in mat4 transform){
+                 vec3 p0 = project_vec3( bb_min, transform );
+                 vec3 p1 = project_vec3( vec3(bb_min.xy, bb_max.z), transform );
+                 
+                 pb_min = min( p0, p1 );
+                 pb_max = max( p0, p1 );
+                 
+                 vec3 p2 = project_vec3( vec3(bb_min.x, bb_max.y, bb_min.z),  transform );
+                 
+                 pb_min = min( pb_min, p2 );
+                 pb_max = max( pb_max, p2 );
+                 
+                 vec3 p3 = project_vec3( vec3( bb_min.x, bb_max.y, bb_max.z ), transform );
+                 
+                 pb_min = min( pb_min, p3 );
+                 pb_max = max( pb_max, p3 );
+                 
+                 vec3 p4 = project_vec3( vec3( bb_max.x, bb_min.y, bb_min.z), transform );
+                 
+                 pb_min = min( pb_min, p4 );
+                 pb_max = max( pb_max, p4 );
+                 
+                 vec3 p5 = project_vec3( vec3( bb_max.x, bb_min.y, bb_max.z ), transform );
+                 
+                 pb_min = min( pb_min, p5 );
+                 pb_max = max( pb_max, p5 );
+                 
+                 vec3 p6 = project_vec3( vec3( bb_max.x, bb_max.y, bb_min.z ), transform );
+                 
+                 pb_min = min( pb_min, p6 );
+                 pb_max = max( pb_max, p6 );
+                 
+                 vec3 p7 = project_vec3( vec3( bb_max.x, bb_max.y, bb_max.z ), transform );
+                 
+                 pb_min = min( pb_min, p7 );
+                 pb_max = max( pb_max, p7 );
+            }
+            
+            int compute_mip_level_for_dimension(float mip_limit, float ndc_extents){
+                 return max(0, int( floor( mip_limit - log2( 1.0 / ndc_extents) ) ) );
+            }
+            
+            float query_depth_from_screen_space_bb(in vec3 pb_min, in vec3 pb_max){
+                 vec3 n_min = clamp( (pb_min+1.0)*0.5, 0.0, 1.0);
+                 vec3 n_max = clamp( (pb_max+1.0)*0.5, 0.0, 1.0);
+            
+                 float bb_width = ( n_max.x - n_min.x ) * 0.5;
+                 float bb_height = ( n_max.y - n_min.y ) * 0.5 ;
+            
+                 // pick coarsest z-buffer mip to test 4x4 pixels of the bounding box against
+                 int mip_level_x = compute_mip_level_for_dimension( uDepthMipLimits.x, bb_width );
+                 int mip_level_y = compute_mip_level_for_dimension( uDepthMipLimits.y, bb_height );
+                 
+                 // figure out which mip level to use
+                 int mip_to_use = max(mip_level_x, mip_level_y);
+                 
+                 // sample 4 pixels that cover AABB
+                 float n0 = textureLod(utDepth, n_min.xy, float(mip_to_use)).x;
+                 float n1 = textureLod(utDepth, vec2(n_min.x, n_max.y), float(mip_to_use)).x;
+                 float n2 = textureLod(utDepth, vec2(n_max.y, n_min.y), float(mip_to_use)).x;
+                 float n3 = textureLod(utDepth, n_max.xy, float(mip_to_use)).x;
+                 
+                 float n = max(n0, max(n1, max(n2,n3)));
+                 
+                 float depth_delta = n - n_min.z;
+                 
+                 return depth_delta;
+                 // return float( uDepthMipLimits.x );
+                 // return float( depth_delta*255.0 );
+            }
+            
+            uint query_bounds(vec3 bb_min, vec3 bb_max, mat4 transform){
+                 vec3 pb_min;
+                 vec3 pb_max;
+                 
+                 // project bounds to screen space
+                 project_aabb(pb_min, pb_max, bb_min, bb_max, transform);
+                 
+                 if(
+                    pb_max.x < -1.0 || pb_max.y < -1.0 || pb_max.z < -1.0
+                    || pb_min.x > 1.0 || pb_min.y > 1.0 || pb_min.z > 1.0
+                    ){
+                    // outside of view frustum
+                    return 0u;
+                 }
+                 
+                 float n = query_depth_from_screen_space_bb( pb_min, pb_max );
+                 
+                 if(n < 0.0){
+                    return 0u;
+                 }else{
+                    return 255u;
+                 }
+            }
+            
+            void main() {
+                 ivec2 input_offset = ivec2( int(gl_FragCoord.x) * ITEM_SIZE, int(gl_FragCoord.y) );
+                 
+                 vec3 bb_min = read_input_v3(input_offset);
+                 vec3 bb_max = read_input_v3(input_offset + ivec2(3,0));
+                 mat4 transform = read_input_m4(input_offset + ivec2(6,0));
+               
+                 out_value = vec4( float( query_bounds(bb_min, bb_max, transform)  ) / 255.0, 0.0, 0.0, 1.0 );
+            }
+        `,
+        depthTest: false,
+        depthWrite: false,
+        uniforms: {
+            utDepth: {
+                value: null
+            },
+            utInput: {
+                value: null
+            },
+            uDepthMipLimits: {
+                value: new Vector2(1, 1)
+            }
+        },
+        glslVersion: GLSL3
+    });
+}

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -64,7 +64,6 @@ export class ShadowMapRenderer {
         this.__renderer = renderer;
 
         this.__ensure_map(shadow, renderer);
-        shadow_camera.updateProjectionMatrix();
 
         // draw scene from perspective of shadow camera into the render texture
 
@@ -92,7 +91,7 @@ export class ShadowMapRenderer {
 
         renderer.clear(true, true, false);
 
-        shadow.updateMatrices(light);
+        shadow.updateMatrices(light, 0);
 
         this.onBeforeRender.send3(renderer, shadow_camera, scene);
 
@@ -123,6 +122,16 @@ export class ShadowMapRenderer {
     __do_vsm_pass(shadow) {
         const _renderer = this.__renderer;
 
+        if (shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples) {
+
+            shadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples;
+            shadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples;
+
+            shadowMaterialVertical.needsUpdate = true;
+            shadowMaterialHorizontal.needsUpdate = true;
+
+        }
+
         // vertical pass
 
         const vertical = shadowMaterialVertical.uniforms;
@@ -181,6 +190,7 @@ export class ShadowMapRenderer {
             shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
             shadow.map.texture.name = '.shadowMap';
 
+            shadow.camera.updateProjectionMatrix();
         }
     }
 }

package/engine/graphics/texture/cubemap/buildCubeURLs.js

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {String} path
+ * @param {String} format
+ * @returns {String[]}
+ */
+export function buildCubeURLs(path, format) {
+    return [
+        path + "posx" + format, path + "negx" + format,
+        path + "posy" + format, path + "negy" + format,
+        path + "posz" + format, path + "negz" + format
+    ];
+}

package/engine/graphics/texture/cubemap/load_environment_map.d.ts

@@ -0,0 +1,8 @@
+import {CubeTexture, WebGLRenderer} from "three";
+
+export function load_environment_map(args: {
+    path: (string | string[]),
+    renderer?: WebGLRenderer,
+    original?: boolean,
+    filtered?: boolean
+}): Promise<{ original?: CubeTexture, filtered?: CubeTexture }>

package/engine/graphics/texture/cubemap/load_environment_map.js

@@ -0,0 +1,163 @@
+import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
+import { CubeTextureLoader, LinearFilter, PMREMGenerator, sRGBEncoding, TextureLoader, UnsignedByteType } from "three";
+import { noop } from "../../../../core/function/Functions.js";
+import { computeFileExtension } from "../../../../core/FilePath.js";
+import { HDRCubeTextureLoader } from "three/examples/jsm/loaders/HDRCubeTextureLoader.js";
+
+/**
+ *
+ * @param {string[]|string} paths
+ * @return {Promise<THREE.CubeTexture>}
+ */
+function load_cube_texture(paths) {
+    // piece-wise cubemap, a collection of images for each face
+    const cubeTextureLoader = new CubeTextureLoader();
+    return new Promise((resolve, reject) => {
+        cubeTextureLoader.load(
+            paths,
+            texture => {
+                texture.magFilter = LinearFilter;
+                texture.encoding = sRGBEncoding;
+                resolve(texture);
+            },
+            noop,
+            reject
+        );
+    });
+}
+
+/**
+ *
+ * @param {string[]|string} paths
+ * @return {Promise<THREE.CubeTexture>}
+ */
+function load_hdr_cube_texture(paths) {
+    // piece-wise cubemap, a collection of images for each face
+    const cubeTextureLoader = new HDRCubeTextureLoader();
+    return new Promise((resolve, reject) => {
+        cubeTextureLoader.load(
+            paths,
+            texture => {
+                resolve(texture);
+            },
+            noop,
+            reject
+        );
+    });
+}
+
+/**
+ *
+ * @param {string} path
+ * @return {Promise<THREE.Texture>}
+ */
+function load_exr_texture(path) {
+    return new Promise((resolve, reject) => {
+        new EXRLoader()
+            .setDataType(UnsignedByteType)
+            .load(path, texture => {
+                resolve(texture);
+            }, noop, reject);
+    })
+}
+
+/**
+ *
+ * @param {string} path
+ * @return {Promise<THREE.Texture>}
+ */
+function load_standard_texture(path) {
+    return new Promise((resolve, reject) => {
+        new TextureLoader()
+            .load(path, texture => {
+                texture.encoding = sRGBEncoding;
+                resolve(texture);
+            }, noop, reject);
+    })
+}
+
+/**
+ *
+ * @param {string|string[]} path
+ * @param {THREE.WebGLRenderer} [renderer]
+ * @param {boolean} [original]
+ * @param {boolean} [filtered]
+ * @returns {{original?:THREE.CubeTexture, filtered?: THREE.CubeTexture}}
+ */
+export async function load_environment_map({ path, renderer, original = false, filtered = true }) {
+    /**
+     * @type {string} 'e' or 'c'
+     */
+    let type;
+
+    /**
+     * @type {THREE.WebGLCubeRenderTarget}
+     */
+    let cube_rt;
+
+    /**
+     * @type {THREE.Texture|THREE.CubeTexture}
+     */
+    let texture;
+
+    if (Array.isArray(path)) {
+        const ext = computeFileExtension(path[0]);
+
+        if (ext === 'hdr') {
+            texture = await load_hdr_cube_texture(path);
+        } else {
+            texture = await load_cube_texture(path);
+        }
+
+        type = 'c';
+
+    } else if (typeof path === 'string') {
+        // single cubemap
+        const extension = computeFileExtension(path).toLowerCase();
+        if (extension === 'exr') {
+            texture = await load_exr_texture(path);
+        } else if (extension === 'jpg') {
+            texture = await load_standard_texture(path);
+        } else {
+            // unsupported extension
+            throw new Error(`Unsupported cube map texture extension '${extension}'`);
+        }
+
+        type = 'e';
+
+    } else {
+        throw new Error(`Unsupported parameter format: '${path}'`);
+    }
+
+    const result = {};
+
+    if (filtered) {
+
+        if (renderer === undefined) {
+            throw new Error('renderer argument not supplied, expected a WebGLRenderer');
+        }
+
+        const pmremGenerator = new PMREMGenerator(renderer);
+
+        if (type === 'c') {
+            cube_rt = pmremGenerator.fromCubemap(texture);
+        } else if (type === 'e') {
+            cube_rt = pmremGenerator.fromEquirectangular(texture);
+        } else {
+            throw new Error(`Unsupported cubemap type '${type}'`);
+        }
+
+        pmremGenerator.dispose();
+
+        result.filtered = cube_rt.texture;
+    }
+
+    if (original) {
+        result.original = texture;
+    } else {
+        // cleanup
+        texture.dispose();
+    }
+
+    return result;
+}

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -3,13 +3,13 @@
  */
 
 
-import Vector4 from "../../../../core/geom/Vector4.js";
 import { clamp } from "../../../../core/math/clamp.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { mix } from "../../../../core/math/mix.js";
 import { BlendingType } from "./BlendingType.js";
 import { assert } from "../../../../core/assert.js";
+import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstance.js";
 
 function v2CrossMag(ax, ay, bx, by) {
     return ax * by - ay * bx;
@@ -1319,8 +1319,8 @@ Sampler2D.prototype.fill = function (x, y, width, height, value) {
  * @param {number} value
  */
 Sampler2D.prototype.writeChannel = function (x, y, channel, value) {
-    assert.typeOf(x, "number", "x");
-    assert.typeOf(y, "number", "y");
+    assert.isNumber(x, "x");
+    assert.isNumber(y, "y");
 
     assert.greaterThanOrEqual(x, 0);
     assert.greaterThanOrEqual(y, 0);
@@ -1385,32 +1385,6 @@ Sampler2D.prototype.traverseCircle = function (centerX, centerY, radius, visitor
     }
 };
 
-export function arrayConstructorByInstance(a) {
-    if (a instanceof Int8Array) {
-        return Int8Array;
-    } else if (a instanceof Int16Array) {
-        return Int16Array;
-    } else if (a instanceof Int32Array) {
-        return Int32Array;
-    } else if (a instanceof Uint8Array) {
-        return Uint8Array;
-    } else if (a instanceof Uint8ClampedArray) {
-        return Uint8ClampedArray;
-    } else if (a instanceof Uint16Array) {
-        return Uint16Array;
-    } else if (a instanceof Uint32Array) {
-        return Uint32Array;
-    } else if (a instanceof Float32Array) {
-        return Float32Array;
-    } else if (a instanceof Float64Array) {
-        return Float64Array;
-    } else if (Array.isArray(a)) {
-        return Array;
-    } else {
-        throw new TypeError(`Unsupported array type`);
-    }
-}
-
 /**
  *
  * @param {number} x
@@ -1419,31 +1393,40 @@ export function arrayConstructorByInstance(a) {
  */
 Sampler2D.prototype.resize = function (x, y, preserveData = true) {
 
+    const _w = this.width;
+    const _h = this.height;
+
+    if (_w === x && _h === y) {
+        // size didn't change
+        return;
+    }
+
     const itemSize = this.itemSize;
+
     const length = x * y * itemSize;
 
     const oldData = this.data;
 
-    const Constructor = arrayConstructorByInstance(oldData);
+    const Constructor = typedArrayConstructorByInstance(oldData);
 
     const newData = new Constructor(length);
 
     if (preserveData) {
         //copy old data
-        if (x === this.width) {
+        if (x === _w) {
             // number of columns is preserved, we can just copy the old data across
             newData.set(oldData.subarray(0, Math.min(oldData.length, length)));
         } else {
             //we need to copy new data row-by-row
-            const rowCount = min2(y, this.height);
+            const rowCount = min2(y, _h);
 
-            const columnCount = min2(x, this.width);
+            const columnCount = min2(x, _w);
 
             for (let i = 0; i < rowCount; i++) {
                 for (let j = 0; j < columnCount; j++) {
 
                     const targetItemAddress = (i * x + j) * itemSize;
-                    const sourceItemAddress = (i * this.width + j) * itemSize;
+                    const sourceItemAddress = (i * _w + j) * itemSize;
 
                     for (let k = 0; k < itemSize; k++) {
 
@@ -1457,6 +1440,7 @@ Sampler2D.prototype.resize = function (x, y, preserveData = true) {
 
     this.width = x;
     this.height = y;
+
     this.data = newData;
 };
 
@@ -1563,31 +1547,3 @@ Sampler2D.prototype.traverseOrthogonalNeighbours = function (x, y, visitor, this
     }
 };
 
-/**
- *
- * @param {Sampler2D} sampler0
- * @param {Sampler2D} sampler1
- * @returns {Sampler2D}
- */
-export function differenceSampler(sampler0, sampler1) {
-    let v0 = new Vector4();
-    let v1 = new Vector4();
-    //
-    const width = sampler0.width;
-    const height = sampler0.height;
-    //
-    const difference = new Float32Array(width * height);
-    for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-            v0 = sampler0.get(x, y, v0);
-            v1 = sampler1.get(x, y, v1);
-            v0.normalize();
-            v1.normalize();
-            //check distance
-            difference[x + y * width] = 1 - v0.dot(v1);
-        }
-    }
-    //
-    const sampleD = new Sampler2D(difference, 1, width, height);
-    return sampleD;
-}

package/engine/graphics/texture/sampler/TextureBinaryBufferSerializer.js

@@ -2,8 +2,8 @@ import { DataTypeIndices } from "../../../../core/collection/table/DataTypeIndic
 import { Sampler2D } from "./Sampler2D.js";
 import { EndianType } from "../../../../core/binary/BinaryBuffer.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import { assert } from "../../../../core/assert.js";
+import { DataTypeByteSizes } from "../../../../core/collection/table/DataTypeByteSizes.js";
 
 
 /**

package/engine/graphics/texture/sampler/convertTexture2Sampler2D.js

@@ -1,7 +1,8 @@
 import { WebGLRendererPool } from "../../render/RendererPool.js";
-import ImageFilter, { flipArrayInPlace } from "../../filter/ImageFilter.js";
+import ImageFilter from "../../filter/ImageFilter.js";
 import { Sampler2D } from "./Sampler2D.js";
 import CopyShader from "../../postprocess/threejs/shaders/CopyShader.js";
+import { flipArrayInPlace } from "../../filter/FlipArrayInPlace.js";
 
 
 const DEFAULT_TEXTURE_WIDTH = 512;
@@ -65,7 +66,7 @@ export function convertTexture2Sampler2D(texture, width, height, flipY = true) {
                 value: texture,
                 type: 't'
             },
-            "opacity": { value: 1.0 }
+            opacity: { value: 1.0 }
         }
     });
 

package/engine/graphics/texture/sampler/debug/paintSamplerOnHTML.js

@@ -1,6 +1,7 @@
-import { arrayConstructorByInstance, Sampler2D } from "../Sampler2D.js";
+import { Sampler2D } from "../Sampler2D.js";
 import { scaleSampler2D } from "../scaleSampler2D.js";
 import convertSampler2D2Canvas from "../Sampler2D2Canvas.js";
+import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInstance.js";
 
 /**
  *
@@ -14,7 +15,7 @@ export function paintSamplerOnHTML(s, x, y, scale, offset) {
 
     const d = 180;
 
-    const target = new Sampler2D(arrayConstructorByInstance(s.data), s.itemSize, d, d);
+    const target = new Sampler2D(typedArrayConstructorByInstance(s.data), s.itemSize, d, d);
 
     scaleSampler2D(s, target);
 

package/engine/graphics/texture/sampler/differenceSampler.js

@@ -0,0 +1,31 @@
+import Vector4 from "../../../../core/geom/Vector4.js";
+import { Sampler2D } from "./Sampler2D.js";
+
+/**
+ *
+ * @param {Sampler2D} sampler0
+ * @param {Sampler2D} sampler1
+ * @returns {Sampler2D}
+ */
+export function differenceSampler(sampler0, sampler1) {
+    let v0 = new Vector4();
+    let v1 = new Vector4();
+    //
+    const width = sampler0.width;
+    const height = sampler0.height;
+    //
+    const difference = new Float32Array(width * height);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            v0 = sampler0.get(x, y, v0);
+            v1 = sampler1.get(x, y, v1);
+            v0.normalize();
+            v1.normalize();
+            //check distance
+            difference[x + y * width] = 1 - v0.dot(v1);
+        }
+    }
+    //
+    const sampleD = new Sampler2D(difference, 1, width, height);
+    return sampleD;
+}

package/engine/graphics/texture/sampler/typedArrayConstructorByInstance.js

@@ -0,0 +1,25 @@
+export function typedArrayConstructorByInstance(a) {
+    if (a instanceof Int8Array) {
+        return Int8Array;
+    } else if (a instanceof Int16Array) {
+        return Int16Array;
+    } else if (a instanceof Int32Array) {
+        return Int32Array;
+    } else if (a instanceof Uint8Array) {
+        return Uint8Array;
+    } else if (a instanceof Uint8ClampedArray) {
+        return Uint8ClampedArray;
+    } else if (a instanceof Uint16Array) {
+        return Uint16Array;
+    } else if (a instanceof Uint32Array) {
+        return Uint32Array;
+    } else if (a instanceof Float32Array) {
+        return Float32Array;
+    } else if (a instanceof Float64Array) {
+        return Float64Array;
+    } else if (Array.isArray(a)) {
+        return Array;
+    } else {
+        throw new TypeError(`Unsupported array type`);
+    }
+}

package/engine/graphics/texture/sampler/util/drawSamplerHTML.js

@@ -1,6 +1,7 @@
-import { arrayConstructorByInstance, Sampler2D } from "../Sampler2D.js";
+import { Sampler2D } from "../Sampler2D.js";
 import { scaleSampler2D } from "../scaleSampler2D.js";
 import convertSampler2D2Canvas from "../Sampler2D2Canvas.js";
+import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInstance.js";
 
 /**
  *
@@ -15,7 +16,7 @@ import convertSampler2D2Canvas from "../Sampler2D2Canvas.js";
 export function drawSamplerHTML(parentNode, sampler, x, y, scale, offset, size) {
 
 
-    const target = new Sampler2D(arrayConstructorByInstance(sampler.data), sampler.itemSize, size, size);
+    const target = new Sampler2D(typedArrayConstructorByInstance(sampler.data), sampler.itemSize, size, size);
 
     scaleSampler2D(sampler, target);