@woosh/meep-engine 2.33.64 → 2.33.69

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.64",
+  "version": "2.33.69",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",