@woosh/meep-engine 2.33.3 → 2.33.8

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

@@ -0,0 +1,174 @@
+import {
+    ClampToEdgeWrapping,
+    DataTexture,
+    FloatType,
+    NearestFilter,
+    RedFormat,
+    RGBAFormat,
+    UnsignedByteType,
+    WebGLRenderTarget
+} from "three";
+import { array_copy } from "../../../../../../core/collection/array/copyArray.js";
+import { makeQueryShader } from "./QueryShader.js";
+import { renderScreenSpace } from "../../../utils/renderScreenSpace.js";
+import { assert } from "../../../../../../core/assert.js";
+import { max2 } from "../../../../../../core/math/max2.js";
+
+/**
+ * Query element contains following data:
+ *  [AABB( x0,y0,z0, x1,y1,z1 ) :: Float32], [MATRIX4( ... x16 ) :: Float32]
+ * @type {number}
+ * @readonly
+ */
+const QUERY_ELEMENT_SIZE = 22;
+
+
+export class BatchOcclusionQuery {
+    constructor() {
+        const input_texture = new DataTexture(new Float32Array(1), 1, 1);
+
+        input_texture.format = RedFormat;
+        input_texture.type = FloatType;
+        input_texture.internalFormat = 'R32F';
+        input_texture.generateMipmaps = false;
+        input_texture.wrapT = ClampToEdgeWrapping;
+        input_texture.wrapS = ClampToEdgeWrapping;
+        input_texture.minFilter = NearestFilter;
+        input_texture.magFilter = NearestFilter;
+
+        this.__input_data_texture = input_texture;
+
+        this.__output_data_texture = new WebGLRenderTarget(1, 1, {
+            minFilter: NearestFilter,
+            magFilter: NearestFilter,
+            format: RGBAFormat,
+            type: UnsignedByteType,
+            // internalFormat: 'R8',
+            depthBuffer: false,
+            stencilBuffer: false,
+            wrapS: ClampToEdgeWrapping,
+            wrapT: ClampToEdgeWrapping,
+            generateMipmaps: false
+        });
+
+        this.__size = -1;
+
+        /**
+         *
+         * @type {ShaderMaterial}
+         * @private
+         */
+        this.__material = makeQueryShader();
+        this.__material.defines.ITEM_SIZE = QUERY_ELEMENT_SIZE;
+    }
+
+    /**
+     *
+     * @return {THREE.Texture}
+     */
+    getResultTexture() {
+        return this.__output_data_texture.texture;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    getSize() {
+        return this.__size;
+    }
+
+    /**
+     *
+     * @param {number} count
+     */
+    setSize(count) {
+        if (this.__size === count) {
+            return;
+        }
+
+        this.__size = count;
+
+        /**
+         * How many query elements are packed per texture row
+         * @type {number}
+         * @readonly
+         */
+        const TEXTURE_COLUMN_COUNT = max2(
+            Math.ceil(Math.sqrt(count)),
+            4
+        );
+
+        const input_texture = this.__input_data_texture;
+
+        input_texture.dispose();
+
+        const row_count = Math.ceil(count / TEXTURE_COLUMN_COUNT);
+
+        const input_image = input_texture.image;
+
+        input_image.width = TEXTURE_COLUMN_COUNT * QUERY_ELEMENT_SIZE;
+        input_image.height = row_count;
+        input_image.data = new Float32Array(input_image.width * input_image.height);
+
+        this.__output_data_texture.setSize(TEXTURE_COLUMN_COUNT, row_count);
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number[]|Float32Array} aabb bounding box of the queries region
+     * @param {number[]} transform 4x4 transform matrix
+     */
+    setElement(index, aabb, transform) {
+        assert.lessThan(index, this.__size, 'index overflow');
+        assert.isNonNegativeInteger(index, 'index');
+
+        // write query element
+        const address = index * QUERY_ELEMENT_SIZE;
+
+        const input_texture = this.__input_data_texture;
+
+        /**
+         *
+         * @type {Uint8ClampedArray}
+         */
+        const data = input_texture.image.data;
+
+        array_copy(aabb, 0, data, address, 6);
+        array_copy(transform, 0, data, address + 6, 16);
+
+        input_texture.needsUpdate = true;
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {Uint8Array} destination
+     */
+    readResultTexture(renderer, destination) {
+        const rt = this.__output_data_texture;
+
+        renderer.readRenderTargetPixels(rt, 0, 0, rt.width, rt.height, destination);
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {HierarchicalZBuffer} hiz_buffer
+     */
+    execute(renderer, hiz_buffer) {
+        const uniforms = this.__material.uniforms;
+
+        uniforms.utDepth.value = hiz_buffer.getTexture();
+        uniforms.utInput.value = this.__input_data_texture;
+        uniforms.uDepthMipLimits.value.set(hiz_buffer.mip_limits.x, hiz_buffer.mip_limits.y);
+
+        const __rt = renderer.getRenderTarget();
+        renderer.setRenderTarget(this.__output_data_texture);
+
+        renderScreenSpace(renderer, this.__material);
+
+        renderer.setRenderTarget(__rt);
+    }
+}

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;
+}