@woosh/meep-engine 2.33.4 → 2.33.5

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/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,137 @@
+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";
+
+/**
+ *
+ * @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 => {
+                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)) {
+        texture = await load_cube_texture(path);
+
+        texture.magFilter = LinearFilter;
+        texture.encoding = sRGBEncoding;
+
+        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/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/virtual/v2/ShaderUsage.js

@@ -14,27 +14,28 @@ function vertex() {
 function fragment() {
     return `
 uniform vec4 u_mt_tex; // [ width, height, tileSize, id ]
+uniform vec2 u_mt_params; // [ bias, maxLevel, xx, xx ]
+varying vec2 vUv;
+
 float MTCalculateMipLevel( const in vec2 uv, const in float bias ) {
     vec2 dx = dFdx( uv * u_mt_tex.x );
     vec2 dy = dFdy( uv * u_mt_tex.y );
     return log2( max( dot( dx, dx ), dot( dy, dy ) ) ) / 2.0 + bias;
 }
 
-uniform vec2 u_mt_params; // [ bias, maxLevel, xx, xx ]
 vec4 MTCalculateTileKeyRGBA( const in vec2 uv ) {
    float level = clamp( floor( MTCalculateMipLevel( uv, u_mt_params.x ) ), 0.0, u_mt_params.y );
    vec2 texIS = uv.xy * u_mt_tex.xy;                     // [0-1]x[0-1] -> [0-texwidth]x[0-texheight]
    vec2 texLS = texIS / exp2( level );                   // -> [0-levelwidth]x[0-levelheight]
    vec2 texTS = floor( texLS / u_mt_tex.z );             // -> [0->tileswide]x[0-tileshigh]
-   return vec4( u_mt_params.y - level, texTS.xy, u_mt_tex.w ) / 255.0; // [ texId, level, tileX, tileY ] -> RGBA
+   return vec4( u_mt_params.y - level, texTS.xy, u_mt_tex.w ) / 255.0; // [  level, tileX, tileY, texId ] -> RGBA
 }
 
-    varying vec2 vUv;
     
 void main(){
     vec4 tile =  MTCalculateTileKeyRGBA(vUv);
     // gl_FragColor = tile;
-    gl_FragColor = vec4(mix(0.1,1.0,tile.x*255.0), tile.yz*64.0, 1.0);
+    gl_FragColor = vec4(mix(0.1,1.0,tile.x*255.0/u_mt_params.y), tile.yz*64.0, 1.0);
     // gl_FragColor = MTCalculateTileKeyRGBA(vUv);
     // gl_FragColor = vec4(1.0);
 }
@@ -44,4 +45,4 @@ void main(){
 export {
     vertex,
     fragment
-};
+};

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

@@ -1,5 +1,6 @@
 import * as THREE from "three";
 import { fragment, vertex } from "./ShaderUsage.js";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
 
 let camera, renderer, clock, scene;
 
@@ -22,7 +23,14 @@ function init() {
     const textureLoader = new THREE.TextureLoader();
 
     uniforms = {
-        "u_mt_params": { value: new THREE.Vector2(0.1, 5) },
+        "u_mt_params": { value: new THREE.Vector2(0.1, 6) },
+        /**
+         * Format: VT_WIDTH, VT_HEIGHT, VT_TILE_SIZE, VT_ID
+         *   - VT_WIDTH :       width of the virtual texture
+         *   - VT_HEIGHT :      height of the virtual texture
+         *   - VT_TILE_SIZE :   resolution of a single tile
+         *   - VT_ID :          multiple different virtual textures may be used, this identifies current texture
+         */
         "u_mt_tex": { value: new THREE.Vector4(16384, 16384, 256, 1) }
     };
 
@@ -30,11 +38,11 @@ function init() {
 
     const material = new THREE.ShaderMaterial({
 
-                                                  uniforms: uniforms,
-                                                  vertexShader: vertex(),
-                                                  fragmentShader: fragment()
+        uniforms: uniforms,
+        vertexShader: vertex(),
+        fragmentShader: fragment()
 
-                                              });
+    });
 
     mesh = new THREE.Mesh(new THREE.TorusGeometry(size, 0.3, 30, 30), material);
     mesh.rotation.x = 0.3;
@@ -57,6 +65,8 @@ function init() {
 
     window.addEventListener("resize", onWindowResize);
 
+    new OrbitControls(camera, renderer.domElement);
+
 }
 
 function onWindowResize() {
@@ -88,4 +98,4 @@ function render() {
     renderer.clear();
     renderer.render(scene, camera)
 
-}
+}

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.4",
+  "version": "2.33.5",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",