@woosh/meep-engine 2.33.65 → 2.33.67

package/core/geom/2d/quad-tree/QuadTreeNode.js

@@ -315,8 +315,9 @@ export class QuadTreeNode extends AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        const xm = (x0 + x1) / 2;
-        const ym = (y0 + y1) / 2;
+        // get center point
+        const xm = (x0 + x1) * 0.5;
+        const ym = (y0 + y1) * 0.5;
 
         for (; i < dataLength; i++) {
             const datum = data[i];

package/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js

@@ -1,4 +1,5 @@
 import { Matrix4, NormalBlending, ShaderMaterial, Vector2, Vector4 } from "three";
+import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../../../graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
 /**
  Shader for drawing fog of war as a screen-space post-process effect
@@ -6,16 +7,7 @@ import { Matrix4, NormalBlending, ShaderMaterial, Vector2, Vector4 } from "three
  */
 export function buildScreenSpaceFogOfWarShader() {
     function vertexShader() {
-        return `        
-        varying vec2 vUv;
-
-        void main() {
-
-            vUv = uv;
-                
-            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
-            
-        }`;
+        return FULL_SCREEN_QUAD_VERTEX_SHADER;
     }
 
     function fragmentShader() {

package/engine/ecs/grid/NormalMap2AOMap.js

@@ -5,11 +5,10 @@
 
 import { ClampToEdgeWrapping, DataTexture, RGBAFormat, UnsignedByteType, Vector2 } from 'three';
 import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
-import sampler2D2Texture from '../../graphics/texture/sampler/Sampler2D2Texture.js';
 import AmbientOcclusionShader from '../../graphics/shaders/AmbientOcclusionShader.js';
-import GaussianBlurShader from '../../graphics/shaders/GaussianBlurShader.js';
 import ImageFilter from '../../graphics/filter/ImageFilter.js';
 import { sampler2DtoFloat32Texture } from "../../graphics/texture/sampler/sampler2DToFloat32Texture.js";
+import { DenoiseShader } from "../../graphics/shaders/DenoiseShader.js";
 
 function filterResult2Texture(data, width, height) {
     const result = new DataTexture();
@@ -37,6 +36,7 @@ function filterResult2Texture(data, width, height) {
  * @param {Sampler2D} heightMap
  * @param {Sampler2D} normalMap
  * @param {Vector2} resultSize
+ * @param worldSize
  * @param {number} [rayLength]
  * @returns {Sampler2D}
  */
@@ -45,13 +45,13 @@ function normalMap2OcclusionMap(
     heightMap,
     normalMap,
     resultSize,
+    worldSize = new Vector2(heightMap.width, heightMap.width),
     rayLength = 17
 ) {
     const width = resultSize.x;
     const height = resultSize.y;
-    const resolution = new Vector2(heightMap.width, heightMap.height);
     //
-    const normalTexture = sampler2D2Texture(normalMap, 255, 0.5);
+    const normalTexture = sampler2DtoFloat32Texture(normalMap);
 
     const heightTexture = sampler2DtoFloat32Texture(heightMap);
 
@@ -60,17 +60,16 @@ function normalMap2OcclusionMap(
     const shaderAO = new AmbientOcclusionShader();
     shaderAO.uniforms.heightMap.value = heightTexture;
     shaderAO.uniforms.normalMap.value = normalTexture;
-    shaderAO.uniforms.resolution.value = resolution;
+    shaderAO.uniforms.world_size.value.set(worldSize.x, worldSize.y);
     shaderAO.uniforms.rayLength.value = rayLength;
     //perform filtering
     const rawAO = ImageFilter(renderer, width, height, shaderAO);
 
-    const shaderBlur = new GaussianBlurShader();
-    shaderBlur.uniforms.resolution.value = resolution;
-    shaderBlur.uniforms.tDiffuse.value = filterResult2Texture(rawAO.array, width, height);
-    shaderBlur.uniforms.sigma.value.set(1.3, 1.3);
+    const shaderDenoise = new DenoiseShader(2);
+    shaderDenoise.uniforms.source.value = filterResult2Texture(rawAO.array, width, height);
+    shaderDenoise.uniforms.pixelOffset.value.set(1 / width, 1 / height);
 
-    const smoothAO = ImageFilter(renderer, width, height, shaderBlur);
+    const smoothAO = ImageFilter(renderer, width, height, shaderDenoise);
 
     //create the sampler
     const result = new Sampler2D(new Uint8ClampedArray(width * height), 1, width, height);
@@ -79,9 +78,7 @@ function normalMap2OcclusionMap(
     const size = width * height;
 
     for (let i = 0; i < size; i++) {
-        const i4 = i * 4;
-
-        result.data[i] = smoothAO.array[i4];
+        result.data[i] = smoothAO.array[i * 4];
     }
 
     return result;

package/engine/ecs/terrain/ecs/BuildLightTexture.js

@@ -0,0 +1,106 @@
+import normalMap2AOMap from "../../grid/NormalMap2AOMap.js";
+import heightMap2NormalMap from "../../grid/HeightMap2NormalMap.js";
+import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
+
+/**
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Sampler2D} sampler
+ * @returns {Promise<Sampler2D>}
+ */
+function promiseSamplerNormal(renderer, sampler) {
+
+    console.time("generating normal map");
+    const normalSampler = heightMap2NormalMap(renderer, sampler);
+    console.timeEnd("generating normal map");
+
+
+    return Promise.resolve(normalSampler);
+}
+
+/**
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Promise<Sampler2D>} pSamplerNormal
+ * @param {Sampler2D} samplerHeight
+ * @param {Vector2} resolution
+ * @param {Vector2} [wordSize]
+ * @param {number} rayLength
+ * @returns {Promise<unknown>}
+ */
+function promiseSamplerAO(
+    {
+        renderer,
+        pSamplerNormal,
+        samplerHeight,
+        resolution,
+        wordSize = resolution,
+        rayLength
+    }
+) {
+    return new Promise(function (resolve, reject) {
+        Promise.all([pSamplerNormal]).then(function (values) {
+            const samplerNormal = values[0];
+            console.time("generating AO map");
+            const occlusionSampler = normalMap2AOMap(
+                renderer,
+                samplerHeight,
+                samplerNormal,
+                wordSize,
+                resolution,
+                rayLength
+            );
+            console.timeEnd("generating AO map");
+            //console.info(occlusionSampler);
+            //
+            // paintSamplerOnHTML(samplerHeight, 0, 0, 40, 3);
+            // paintSamplerOnHTML(samplerNormal, 1, 0, 128, 1);
+            // paintSamplerOnHTML(occlusionSampler, 2, 0, 1, 0);
+            //
+            //
+            resolve(occlusionSampler);
+        }, reject);
+    });
+}
+
+/**
+ *
+ * @param {THREE.DataTexture} texture
+ * @param {Vector2} [resolution]
+ * @param {Sampler2D} heightSampler
+ * @param {number} [rayLength]
+ * @param {Vector2} [worldSize]
+ * @returns {Promise}
+ */
+export function buildLightTexture({
+                                      texture,
+                                      heightSampler,
+                                      resolution= new Vector2(texture.image.width, texture.image.height),
+                                      rayLength = 11,
+                                      worldSize = resolution
+                                  }) {
+
+    const renderer = WebGLRendererPool.global.get();
+
+    const normal = promiseSamplerNormal(renderer, heightSampler);
+    const ao = promiseSamplerAO({
+        renderer: renderer,
+        pSamplerNormal: normal,
+        samplerHeight: heightSampler,
+        resolution: resolution,
+        rayLength: rayLength,
+        worldSize
+    });
+
+    const promise = ao.then(sampler => {
+        writeSample2DDataToDataTexture(sampler, texture);
+    });
+
+    Promise.all([normal, ao]).finally(() => {
+        WebGLRendererPool.global.release(renderer);
+    });
+
+    return promise;
+}

package/engine/ecs/terrain/ecs/PromiseSamplerHeight.js

@@ -0,0 +1,59 @@
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
+import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import rgbaData2valueSampler2D from "../../../graphics/texture/sampler/rgbaData2valueSampler2D.js";
+
+/**
+ *
+ * @param zRange
+ * @param heightMapURL
+ * @param {AssetManager} assetManager
+ * @returns {Promise<any>}
+ */
+export function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
+    return new Promise(function (fulfill, reject) {
+
+        function assetObtained(asset) {
+            const array = asset.create();
+
+            const binaryBuffer = new BinaryBuffer();
+            //
+            // binaryBuffer.writeUint32(2560);
+            // binaryBuffer.writeUint32(2560);
+            //
+            // binaryBuffer.writeUint8(1);
+            //
+            // binaryBuffer.writeUint8(6);
+
+            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
+
+            binaryBuffer.position = 0;
+
+            const sampler2D = deserializeTexture(binaryBuffer);
+            fulfill(sampler2D);
+        }
+
+
+        if (heightMapURL === undefined) {
+            console.warn('Height map is not specified');
+            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
+            fulfill(defaultSampler);
+        } else if (heightMapURL.endsWith('.bin')) {
+            //load texture from a binary file
+            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
+        } else {
+            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
+                const image = asset.create();
+
+                // plane
+                const imgWidth = image.width;
+                const imgHeight = image.height;
+
+                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
+
+                fulfill(samplerHeight);
+            }, reject);
+        }
+    });
+}

package/engine/ecs/terrain/ecs/Terrain.js

@@ -14,9 +14,6 @@ import {
 } from 'three';
 import { clamp } from "../../../../core/math/clamp.js";
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
-import heightMap2NormalMap from '../../grid/HeightMap2NormalMap.js';
-import normalMap2AOMap from '../../grid/NormalMap2AOMap.js';
-import rgbaData2valueSampler2D from '../../../graphics/texture/sampler/rgbaData2valueSampler2D.js';
 import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
 import Vector2 from '../../../../core/geom/Vector2.js';
 import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
@@ -24,13 +21,9 @@ import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
 import Clouds from '../TerrainClouds.js';
 
 import TerrainTileManager from '../tiles/TerrainTileManager.js';
-import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
-import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { TerrainPreview } from "../TerrainPreview.js";
 import { assert } from "../../../../core/assert.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
-import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
 import { TerrainLayers } from "./layers/TerrainLayers.js";
 import { SplatMaterial } from "../../../graphics/material/SplatMaterial.js";
 import { loadLegacyTerrainSplats, SplatMapping } from "./splat/SplatMapping.js";
@@ -41,147 +34,8 @@ import { MeepSettings } from "../../../MeepSettings.js";
 import { loadLegacyTerrainLayers } from "./layers/loadLegacyTerrainLayers.js";
 import { TerrainFlags } from "./TerrainFlags.js";
 import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
-
-/**
- *
- * @param zRange
- * @param heightMapURL
- * @param {AssetManager} assetManager
- * @returns {Promise<any>}
- */
-function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
-    return new Promise(function (fulfill, reject) {
-
-        function assetObtained(asset) {
-            const array = asset.create();
-
-            const binaryBuffer = new BinaryBuffer();
-            //
-            // binaryBuffer.writeUint32(2560);
-            // binaryBuffer.writeUint32(2560);
-            //
-            // binaryBuffer.writeUint8(1);
-            //
-            // binaryBuffer.writeUint8(6);
-
-            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
-
-            binaryBuffer.position = 0;
-
-            const sampler2D = deserializeTexture(binaryBuffer);
-            fulfill(sampler2D);
-        }
-
-
-        if (heightMapURL === undefined) {
-            console.warn('Height map is not specified');
-            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
-            fulfill(defaultSampler);
-        } else if (heightMapURL.endsWith('.bin')) {
-            //load texture from a binary file
-            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
-        } else {
-            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
-                const image = asset.create();
-
-                // plane
-                const imgWidth = image.width;
-                const imgHeight = image.height;
-
-                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
-
-                fulfill(samplerHeight);
-            }, reject);
-        }
-    });
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Promise<Sampler2D>}
- */
-function promiseSamplerNormal(renderer, sampler) {
-
-    console.time("generating normal map");
-    const normalSampler = heightMap2NormalMap(renderer, sampler);
-    console.timeEnd("generating normal map");
-
-
-    return Promise.resolve(normalSampler);
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Promise<Sampler2D>} pSamplerNormal
- * @param {Sampler2D} samplerHeight
- * @param {Vector2} resolution
- * @param {number} rayLength
- * @returns {Promise<unknown>}
- */
-function promiseSamplerAO(
-    renderer,
-    pSamplerNormal,
-    samplerHeight,
-    resolution,
-    rayLength
-) {
-    return new Promise(function (resolve, reject) {
-        Promise.all([pSamplerNormal]).then(function (values) {
-            const samplerNormal = values[0];
-            console.time("generating AO map");
-            const occlusionSampler = normalMap2AOMap(
-                renderer,
-                samplerHeight,
-                samplerNormal,
-                resolution,
-                rayLength
-            );
-            console.timeEnd("generating AO map");
-            //console.info(occlusionSampler);
-            //
-            // paintSamplerOnHTML(samplerHeight, 0, 0, 40, 3);
-            // paintSamplerOnHTML(samplerNormal, 1, 0, 128, 1);
-            // paintSamplerOnHTML(occlusionSampler, 2, 0, 1, 0);
-            //
-            //
-            resolve(occlusionSampler);
-        }, reject);
-    });
-}
-
-/**
- *
- * @param {DataTexture} texture
- * @param {Vector2} resolution
- * @param {Sampler2D} heightSampler
- * @param {number} heightRange
- * @param {number} [rayLength]
- * @returns {Promise}
- */
-function buildLightTexture({ texture, heightSampler, resolution, rayLength = 17 }) {
-
-    const renderer = WebGLRendererPool.global.get();
-
-    if (resolution === undefined) {
-        resolution = new Vector2(texture.image.width, texture.image.height);
-    }
-
-    const normal = promiseSamplerNormal(renderer, heightSampler);
-    const ao = promiseSamplerAO(renderer, normal, heightSampler, resolution, rayLength);
-
-    const promise = ao.then(sampler => {
-        writeSample2DDataToDataTexture(sampler, texture);
-    });
-
-    Promise.all([normal, ao]).finally(() => {
-        WebGLRendererPool.global.release(renderer);
-    });
-
-    return promise;
-}
+import { buildLightTexture } from "./BuildLightTexture.js";
+import { promiseSamplerHeight } from "./PromiseSamplerHeight.js";
 
 let idCounter = 0;
 
@@ -903,13 +757,13 @@ class Terrain {
         this.updateWorkerHeights();
     }
 
-    updateWorkerHeights() {
+    async updateWorkerHeights() {
         const s = this.samplerHeight;
         const worker = this.buildWorker;
 
-        worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
+        await worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
-       return worker.computeHeightRange()
+        return await worker.computeHeightRange()
             .then(({ min, max }) => {
                 this.tiles.setHeightRange(min, max);
             });
@@ -1012,7 +866,12 @@ class Terrain {
         this.setFlag(TerrainFlags.Built);
     }
 
-    buildLightMap() {
+    /**
+     *
+     * @param {number} quality resolution in texels per grid cell (4 = 4x4 light map texels per single grid cell)
+     * @return {Promise<DataTexture>}
+     */
+    buildLightMap(quality = 4) {
 
 
         const size_x = this.size.x;
@@ -1035,7 +894,9 @@ class Terrain {
 
         const promise = buildLightTexture({
             texture,
-            heightSampler: this.samplerHeight
+            heightSampler: this.samplerHeight,
+            worldSize: new Vector2(size_x * this.gridScale, size_y * this.gridScale),
+            resolution: new Vector2(size_x * quality, size_y *quality)
         });
 
 

package/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js

@@ -0,0 +1,10 @@
+export const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
+        varying vec2 vUv;
+
+        void main() {
+
+            vUv = uv;
+                
+            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
+            
+        }`;

package/engine/graphics/filter/ImageFilter.js

@@ -5,13 +5,14 @@
 
 import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
 /**
  *
  * @param {WebGLRenderer} renderer
  * @param {number} width
  * @param {number} height
- * @param {{vertexShader:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
+ * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
  * @param {Uint8Array} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
@@ -34,9 +35,12 @@ function processTexture(
     scene.add(camera);
 
     //make a quad to render
-    const material = new ShaderMaterial(processShader);
+    const material = new ShaderMaterial(Object.assign({ vertexShader: FULL_SCREEN_QUAD_VERTEX_SHADER }, processShader));
+
     material.lights = false;
     material.fog = false;
+    material.uniformsNeedUpdate = true;
+    material.needsUpdate = true;
 
     const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -43,10 +43,15 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
             return attached_micron;
         }
 
-        const existing = await micron_cache.get(g);
+        const cached_micron = await micron_cache.get(g);
 
-        if (existing !== undefined && existing !== null) {
-            return existing;
+
+        if (cached_micron !== undefined && cached_micron !== null) {
+
+            // set proxy
+            cached_micron.proxy = g;
+
+            return cached_micron;
         }
 
         const pending = pending_cache.get(g);
@@ -61,8 +66,14 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         promises.push(micron_geometry_promise);
 
+        /**
+         *
+         * @type {MicronGeometry}
+         */
         const micron_geometry = await micron_geometry_promise;
 
+        micron_geometry.proxy = g;
+
         await micron_cache.set(g, micron_geometry);
 
         return micron_geometry;

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -106,6 +106,9 @@ class GLTFAssetTransformer extends AssetTransformer {
 
         this.__serde.deserialize(buffer, micron_geometry);
 
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
         geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
     }
 

package/engine/graphics/shaders/AmbientOcclusionShader.js

@@ -3,9 +3,6 @@
  */
 import { Vector2 } from "three";
 
-
-const samplesPerPixel = 37;
-
 const AmbientOcclusionShader = function () {
     return {
 
@@ -13,11 +10,16 @@ const AmbientOcclusionShader = function () {
 
             "normalMap": { type: "t", value: null },
             "heightMap": { type: "t", value: null },
-            "resolution": { type: "v2", value: new Vector2(512, 512) },
+            "world_size": { type: "v2", value: new Vector2(512, 512) },
             "rayLength": { type: 'f', value: 17 }
 
         },
 
+        defines: {
+            'NUM_SAMPLES': 64,
+            'NUM_RINGS': 7,
+        },
+
         vertexShader: [
 
             "varying vec2 vUv;",
@@ -33,17 +35,17 @@ const AmbientOcclusionShader = function () {
 
         fragmentShader: [
             `
-            uniform vec2 resolution;
             uniform sampler2D normalMap;
             uniform sampler2D heightMap;
             uniform float rayLength;
+            uniform vec2 world_size;
 
             varying vec2 vUv;
 
             vec3 get(float x, float y){
-               vec2 _uv = vUv.xy + vec2(x,y)/resolution;
+               vec2 _uv = vUv.xy + vec2(x,y) / world_size;
                float h = texture2D(heightMap, _uv).x;
-               return vec3(_uv.x, h, _uv.y);
+               return vec3( _uv.x * world_size.x, h, _uv.y * world_size.y );
             }
             
             float hash1( float n )
@@ -56,92 +58,70 @@ const AmbientOcclusionShader = function () {
                 p  = 50.0*fract( p*0.3183099 );
                 return fract( p.x*p.y*(p.x+p.y) );
             }
-
             
-            float noise( in vec2 x )
-            {
-                vec2 p = floor(x);
-                vec2 w = fract(x);
-                vec2 u = w*w*w*(w*(w*6.0-15.0)+10.0);
-                
-                float a = hash1(p+vec2(0,0));
-                float b = hash1(p+vec2(1,0));
-                float c = hash1(p+vec2(0,1));
-                float d = hash1(p+vec2(1,1));
-                
-                return -1.0+2.0*( a + (b-a)*u.x + (c-a)*u.y + (a - b - c + d)*u.x*u.y );
-            }
-            
-            float noise_01(in vec2 x){
-                return (noise(x) + 1.0)*0.5;
+            // Non-sin based hash function, fast and has good randomness
+            float hash12(vec2 p){
+                vec3 p3  = fract(vec3(p.xyx) * .1031);
+                p3 += dot(p3, p3.yzx + 33.33);
+                return fract((p3.x + p3.y) * p3.z);
             }
             
-            vec3 sampleDirectionFromConicRay(float angle, vec3 direction, vec2 seed){
-                float random_0 = noise_01( seed + vec2(1.123, 3.1)  );
-                float random_1 = noise_01( seed + vec2(3.123, 7.8913)  );
-            
-            
-                float angleCosine = cos(angle);
-                
-                float z = random_0 * (1.0 - angleCosine) + angleCosine;
+            const float bias = 0.001;
             
-                float phi = random_1 * 6.28318530718; //2*pi
+            float pow2(float x){
+                return x*x;
+            }
+    
+            float getOcclusion(vec3 origin, vec3 normal, vec3 hit_position){
+                vec3 viewDelta = hit_position - origin;
                 
-                float zSqr = z*z;
+                float viewDistance = length( viewDelta );
                 
-                float zSqrtNeg = sqrt(1.0 - zSqr);
+                float vn = dot( normal, viewDelta );
+                float a2 = (vn) / viewDistance - bias;
+                float a1 = (1.0 + pow2( viewDistance ) );
                 
-                float x = zSqrtNeg * cos(phi);
-                float y = zSqrtNeg * sin(phi);
+                return max(0.0, a2) / a1;
+            }
                 
-                float dX = direction.x;
-                float dY = direction.y;
-                float dZ = direction.z;
+            const float PI2 = 6.28318530717958;
+            const float kernelRadius = 100.0;
+    
+            const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
+            const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
+            
+            float getAmbientOcclusion(vec3 world_position, vec3 world_normal){
+                // jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
+                float angle = hash12( vUv  ) * PI2;
+                vec2 radius = vec2( rayLength * INV_NUM_SAMPLES );
                 
-                float rot = acos(dZ);
-               
-                float c = dZ;
-                float s = sin(rot);
-                float t = 1.0 - c;
-                float tx = -t * dY;
-                float ty = t * dX;
+                float occlusionSum = 0.0;
+                float weightSum = 0.0;
                 
-                float n11 = c - tx * dY;
-                float n12 = tx * dX;
-                float n22 = ty * dX + c;
-                float n13 = s * dX;
-                float n32 = -s * dY;
+                for( int i = 0; i < NUM_SAMPLES; i ++ ) {
+                    vec2 sampleUv = vec2( cos( angle ), sin( angle ) ) * radius * float(i+1);
+                    
+                    angle += ANGLE_STEP;
+                        
+                    vec3 sample_pos = get(sampleUv.x, sampleUv.y);
                 
-                float _x = n11 * x + n12 * y + n13 * z;
-                float _y = n12 * x + n22 * y + -n32 * z;
-                float _z = -n13 * x + n32 * y + c * z;
+                    occlusionSum += getOcclusion(world_position, world_normal, sample_pos);
+                    weightSum += 1.0;
+                }
                 
-                return vec3(_x, _y, _z);
+                return occlusionSum/weightSum;
             }
-
+            
             void main() {
-               float occlusion = 0.0;
                vec3 pos = get(0.0, 0.0);
-               vec3 normal = texture2D( normalMap, vUv ).xyz;
-
-               for(int i=1; i< ${samplesPerPixel}; i++){
-                 float s = float(i)/${samplesPerPixel - 1}.0;
-                 float a = sqrt(s*512.0);
-                 float b = sqrt(s)*rayLength;
-                 float x = sin(a)*b;
-                 float y = cos(a)*b;
-            
-                 vec3 sample_pos = get(x, y);
-
-                 vec3 sample_dir = normalize(sample_pos - pos);
-                 float vDot = dot(normal, sample_dir);
-                 float lambert = clamp(vDot, 0.0, 1.0);
-                 float dist_factor = 0.23/sqrt(length(sample_pos - pos));
-                 occlusion += dist_factor*lambert;
-               }
                
-               float incident = 1.0 - occlusion/${samplesPerPixel - 1}.0;
-               gl_FragColor = vec4(incident, incident, incident, 1.0);
+               vec3 normal = texture2D( normalMap, vUv ).xzy;
+               
+               float occlusion = getAmbientOcclusion(pos, normal);
+               
+               float incident = 1.0 - occlusion;
+               
+               gl_FragColor = vec4(pow(incident,10.0), 0.0, 0.0, 1.0);
             }
             `
         ].join('\n')

package/engine/graphics/shaders/DenoiseShader.js

@@ -0,0 +1,119 @@
+import { Vector2 } from "three";
+
+const KERNEL_SIZE = 15;
+
+const fragment = `
+// bilateral filter, based on https://www.shadertoy.com/view/4dfGDH# and
+// http://people.csail.mit.edu/sparis/bf_course/course_notes.pdf
+// A bilateral filter is a non-linear, edge-preserving, and noise-reducing smoothing filter for images.
+// It replaces the intensity of each pixel with a weighted average of intensity values from nearby pixels.
+// This weight can be based on a Gaussian distribution. Crucially, the weights depend not only on
+// Euclidean distance of pixels, but also on the radiometric differences (e.g., range differences, such
+// as color intensity, depth distance, etc.). This preserves sharp edges.
+
+float normpdf3(in vec3 v, in float sigma) {
+    return 0.39894 * exp(-0.5 * dot(v, v) / (sigma * sigma)) / sigma;
+}
+
+// filter size
+#define MSIZE ${KERNEL_SIZE}
+varying vec2 vUv;
+uniform sampler2D source;
+uniform vec2 pixelOffset;
+uniform vec2 sigmas;
+uniform float bZnorm;
+uniform float kernel[MSIZE];
+
+void main(void) {
+
+    // range sigma - controls blurriness based on a pixel distance
+    float sigma = sigmas.x;
+    
+    // domain sigma - controls blurriness based on a pixel similarity (to preserve edges)
+    float bSigma = sigmas.y;
+    vec4 pixel = texture2D(source, vUv);
+    vec4 accumulatedColor = vec4(0.0);
+    float accumulatedFactor = 0.0;
+    
+    // read out the texels
+    const int kSize = (MSIZE-1)/2;
+    
+    for (int i = -kSize; i <= kSize; ++i) {
+        for (int j = -kSize; j <= kSize; ++j) {
+
+            // sample the pixel with offset
+            vec2 coord = vUv + vec2(float(i), float(j)) * pixelOffset;
+            vec4 rgba = texture2D(source, coord);
+       
+            // bilateral factors
+            float factor = kernel[kSize + j] * kernel[kSize + i];
+            factor *= normpdf3(rgba.rgb - pixel.rgb, bSigma) * bZnorm;
+            
+            // accumulate
+            accumulatedColor += factor * rgba;
+            accumulatedFactor += factor;
+        }
+    }
+    
+    gl_FragColor = accumulatedColor / accumulatedFactor;
+}
+`;
+
+/**
+ *
+ * @param {number} x
+ * @param {number} sigma
+ * @return {number}
+ */
+function normpdf(x, sigma) {
+    return 0.39894 * Math.exp(-0.5 * x * x / (sigma * sigma)) / sigma;
+}
+
+/**
+ *
+ * @param {number} sigma
+ * @param {number} filterSmoothness
+ * @constructor
+ */
+export function DenoiseShader(sigma = 10, filterSmoothness = 0.2) {
+    // compute zNorm
+    const zNorm = 1 / normpdf(0, filterSmoothness);
+
+    // build kernel
+    const kernel = new Float32Array(KERNEL_SIZE);
+    const kSize = Math.floor((KERNEL_SIZE - 1) / 2);
+    for (let i = 0; i <= kSize; i++) {
+        const v = normpdf(i, sigma);
+
+        kernel[kSize + i] = v;
+        kernel[kSize - i] = v;
+    }
+
+    return {
+        uniforms: {
+            source: {
+                type: 't',
+                value: null
+            },
+            pixelOffset: {
+                type: 'v2',
+                /**
+                 * Holds single pixel size in UV space ( 1 / texture_size )
+                 */
+                value: new Vector2(1, 1)
+            },
+            sigmas: {
+                type: "v2", value: new Vector2(sigma, sigma)
+            },
+            bZnorm: {
+                type: 'f',
+                value: zNorm
+            },
+            kernel: {
+                type: 'f',
+                value: kernel
+            }
+        },
+        fragmentShader: fragment
+    };
+}

package/engine/graphics/texture/noise_octaves.js

@@ -0,0 +1,33 @@
+export function noise_octaves(
+    noise,
+    noise_ctx,
+    x, y, z,
+    octaves,
+    persistence = 0.5,
+    lacunarity = 2
+) {
+    let total = 0;
+    let frequency = 1;
+    let amplitude = 1;
+
+    let totalAmplitude = 0;  // Used for normalizing result to 0.0 - 1.0
+    let i = 0;
+
+    for (; i < octaves; i++) {
+
+        const noise_value = noise.call(noise_ctx,
+            x * frequency,
+            y * frequency,
+            z * frequency
+        );
+
+        total += noise_value * amplitude;
+
+        totalAmplitude += amplitude;
+        amplitude *= persistence;
+        frequency *= lacunarity;
+    }
+
+    return total / totalAmplitude;
+}
+

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

@@ -3,43 +3,32 @@
  */
 import { ClampToEdgeWrapping, DataTexture, RGBAFormat, UnsignedByteType } from 'three';
 import { assert } from "../../../../core/assert.js";
+import { copy_Sampler2D_channel_data } from "./copy_Sampler2D_channel_data.js";
+import { Sampler2D } from "./Sampler2D.js";
 
 
 /**
  *
  * @param {Sampler2D} sampler
- * @param {Number} scale
- * @param {Number} offset
  * @return {DataTexture}
  */
-function sampler2D2Texture(sampler, scale = 1, offset = 0) {
+function sampler2D2Texture(sampler) {
     assert.notEqual(sampler, undefined, 'sampler is undefined');
-    assert.equal(typeof scale, "number", `scale must be a number, instead was '${typeof scale}'`);
-    assert.equal(typeof offset, "number", `scale must be a number, instead was '${typeof offset}'`);
 
     const result = new DataTexture();
     result.format = RGBAFormat;
 
     let data;
 
-    if (scale === 1 && offset === 0 && sampler.itemSize === 4) {
+    if (sampler.itemSize === 4) {
         //no transformation, use a direct reference
         data = sampler.data;
 
     } else {
-        data = new Uint8Array(sampler.width * sampler.height * 4);
-        //slow process with mutation
-        const arrayFiller = sampler.makeArrayFiller(scale, offset);
+        const dest = Sampler2D.uint8(4, sampler.width, sampler.height);
+        copy_Sampler2D_channel_data(sampler, dest);
 
-        let index = 0;
-        let x, y;
-
-        for (y = 0; y < sampler.height; y++) {
-            for (x = 0; x < sampler.width; x++) {
-                arrayFiller(index, data, x, y);
-                index += 4;
-            }
-        }
+        data = dest.data;
     }
 
     result.type = UnsignedByteType;

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

@@ -10,20 +10,23 @@ import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInsta
  * @param {number} y
  * @param scale
  * @param offset
+ * @param {number} resolution
  */
-export function paintSamplerOnHTML(s, x, y, scale, offset) {
+export function paintSamplerOnHTML(s, x, y, scale, offset, resolution=256) {
 
-    const d = 180;
+    const d = resolution;
 
-    const target = new Sampler2D(typedArrayConstructorByInstance(s.data), s.itemSize, d, d);
+    const TA = typedArrayConstructorByInstance(s.data);
+
+    const target = new Sampler2D(new TA(d * d * s.itemSize), s.itemSize, d, d);
 
     scaleSampler2D(s, target);
 
     const c = convertSampler2D2Canvas(target, scale, offset);
     c.style.zIndex = 1000;
     c.style.position = "absolute";
-    c.style.left = `${x * d}px`;
-    c.style.top = `${y * d}px`;
+    c.style.left = `${x}px`;
+    c.style.top = `${y}px`;
 
     document.body.appendChild(c);
 }

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

@@ -1,5 +1,8 @@
-import { ClampToEdgeWrapping, DataTexture, FloatType, LinearFilter, NearestFilter, RedFormat } from "three";
+import { ClampToEdgeWrapping, DataTexture, FloatType, LinearFilter, NearestFilter } from "three";
 import { assert } from "../../../../core/assert.js";
+import { channelCountToThreeTextureFormat } from "../channelCountToThreeTextureFormat.js";
+import { computeThreeTextureInternalFormatFromDataType } from "../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
+import { DataType } from "../../../../core/collection/table/DataType.js";
 
 /**
  *
@@ -12,7 +15,7 @@ export function sampler2DtoFloat32Texture(sampler) {
     const width = sampler.width;
     const height = sampler.height;
 
-    const texture = new DataTexture(sampler.data, width, height, RedFormat, FloatType);
+    const texture = new DataTexture(sampler.data, width, height);
 
     texture.wrapS = ClampToEdgeWrapping;
     texture.wrapT = ClampToEdgeWrapping;
@@ -24,7 +27,11 @@ export function sampler2DtoFloat32Texture(sampler) {
 
     texture.flipY = false;
 
-    texture.internalFormat = 'R32F';
+    texture.type = FloatType;
+    texture.format = channelCountToThreeTextureFormat(sampler.itemSize);
+    texture.internalFormat = computeThreeTextureInternalFormatFromDataType(DataType.Float32, sampler.itemSize);
+
+    texture.needsUpdate = true;
 
     return texture;
 }

package/generation/example/filters/SampleGroundMoistureFilter.js

@@ -24,7 +24,8 @@ export const SampleGroundMoistureFilter = CellFilterAdd.from(
                 CellFilterStep.from(CellFilterLiteralFloat.from(0), fReadHeight)
             ),
             7,
-            7
+            7,
+            1
         ),
         CellFilterLiteralFloat.from(0.6)
     )

package/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -1,9 +1,23 @@
 import { CellFilter } from "../../CellFilter.js";
 import { gaussian } from "../../../../core/math/gaussian.js";
-
+import { max2 } from "../../../../core/math/max2.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} samplesX
+ * @param {number} samplesY
+ * @param {number} sigma_x
+ * @param {number} sigma_y
+ * @return {number}
+ */
 function buildKernel(result, samplesX, samplesY, sigma_x, sigma_y) {
-    const half_samples_x = (samplesX / 2);
-    const half_samples_y = (samplesY / 2);
+    assert.isNonNegativeInteger(samplesX, 'samplesX');
+    assert.isNonNegativeInteger(samplesY, 'samplesY');
+
+    const half_samples_x = samplesX * 0.5;
+    const half_samples_y = samplesY * 0.5;
 
     let powerTotal = 0;
     let ix, iy;
@@ -70,6 +84,8 @@ export class CellFilterGaussianBlur extends CellFilter {
         if (!this.source.initialized) {
             this.source.initialize(grid, seed);
 
+            this.__kernel = new Float32Array(this.samples_x * this.samples_y);
+
             // initialize kernel
             this.__kernel_total_power = buildKernel(this.__kernel, this.samples_x, this.samples_y, this.sigma_x, this.sigma_y);
         }
@@ -84,13 +100,13 @@ export class CellFilterGaussianBlur extends CellFilter {
      * @param {number} quality
      * @returns {CellFilterGaussianBlur}
      */
-    static from(source, x, y, quality = 5) {
+    static from(source, x, y, quality = 3) {
         const r = new CellFilterGaussianBlur();
 
         r.source = source;
 
-        r.samples_x = quality * x;
-        r.samples_y = quality * y;
+        r.samples_x = max2(2, Math.round(quality * x));
+        r.samples_y = max2(2, Math.round(quality * y));
 
         r.size_x = x;
         r.size_y = y;
@@ -102,24 +118,24 @@ export class CellFilterGaussianBlur extends CellFilter {
         const samplesX = this.samples_x;
         const samplesY = this.samples_y;
 
-        const half_samples_x = (samplesX / 2);
-        const half_samples_y = (samplesY / 2);
+        const half_samples_x = (samplesX - 1) * 0.5;
+        const half_samples_y = (samplesY - 1) * 0.5;
 
         const sizeX = this.size_x;
         const sizeY = this.size_y;
 
-        const local_u_scale = 1 / samplesX;
-        const local_v_scale = 1 / samplesY;
+        const local_u_scale = 1 / (samplesX - 1);
+        const local_v_scale = 1 / (samplesY - 1);
 
         let sum = 0;
-        let ix, iy;
+        let ix, iy = 0;
 
         const source = this.source;
         const kernel = this.__kernel;
 
-        const i_samples_x = samplesX|0;
+        const i_samples_x = samplesX | 0;
 
-        for (iy = 0; iy < samplesY; iy++) {
+        for (; iy < samplesY; iy++) {
             const local_y = iy - half_samples_y;
 
             const ny = local_y * local_v_scale;

package/generation/grid/GridData.js

@@ -2,6 +2,7 @@ import { assert } from "../../core/assert.js";
 import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { OffsetScaleTransform2D } from "../../engine/ecs/terrain/ecs/OffsetScaleTransform2D.js";
 import { MarkerMatchCounter } from "./MarkerMatchCounter.js";
+import { max2 } from "../../core/math/max2.js";
 
 const scratch_match_counter = new MarkerMatchCounter();
 
@@ -167,8 +168,14 @@ export class GridData {
      * @param {number} height
      */
     resize(width, height) {
-        assert.typeOf(width, 'number', 'width');
-        assert.typeOf(height, 'number', 'height');
+        assert.isNumber(width, 'width');
+        assert.isNumber(height, 'height');
+
+        assert.isNonNegativeInteger(width,'width');
+        assert.isNonNegativeInteger(height,'height');
+
+        assert.isFiniteNumber(width, 'width');
+        assert.isFiniteNumber(height, 'width');
 
         if (width === this.width && height === this.height) {
             //no need, already the right size
@@ -187,6 +194,14 @@ export class GridData {
 
             layer.resize(width, height);
         }
+
+        // resize the quad tree pre-emptively, to avoid expensive re-balancing operations later on
+        this.markers.resize(
+            -max2(1, width * 0.5),
+            -max2(1, height * 0.5),
+            max2(width + 1, width * 1.5),
+            max2(height + 1, height * 1.5)
+        );
     }
 
     /**

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.65",
+  "version": "2.33.67",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",