@woosh/meep-engine 2.33.65 → 2.33.70

package/engine/graphics/geometry/buffered/query/GeometryVisitor.js

@@ -1,6 +1,6 @@
 import { IndexedBinaryBVHVisitor } from "../../../../../core/bvh2/binary/IndexedBinaryBVHVisitor.js";
 
-export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
+export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor {
     constructor() {
         super();
 
@@ -25,6 +25,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
          */
         this.__buffer_vertices = null;
 
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_vertex_stride = 3;
+
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_position_offset = 0;
+
         /**
          * @protected
          * @type {IndexedBinaryBVH}
@@ -47,7 +61,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
         this.geometry = geometry;
 
         this.__buffer_indices = geometry.getIndex().array;
-        this.__buffer_vertices = geometry.getAttribute('position').array;
+
+        const position_attribute = geometry.getAttribute('position');
+
+        if (position_attribute.isInterleavedBufferAttribute) {
+            const data = position_attribute.data;
+
+            this.__buffer_vertices = data.array;
+            this.__buffer_vertex_stride = data.stride;
+            this.__buffer_position_offset = position_attribute.offset;
+        } else {
+            this.__buffer_vertices = position_attribute.array;
+            this.__buffer_vertex_stride = 3;
+            this.__buffer_position_offset = 0;
+        }
     }
 
 }

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -96,21 +96,32 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             if (computeTriangleRayIntersection(
                 this.__temp_hit,
@@ -120,15 +131,9 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
                 rayDirection.x,
                 rayDirection.y,
                 rayDirection.z,
-                ax,
-                ay,
-                az,
-                bx,
-                by,
-                bz,
-                cx,
-                cy,
-                cz
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
             )) {
                 const d = this.__temp_hit.position.distanceSqrTo(rayOrigin);
 
@@ -154,12 +159,8 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const z1 = data[address + 5];
 
             return intersectRay(
-                x0,
-                y0,
-                z0,
-                x1,
-                y1,
-                z1,
+                x0, y0, z0,
+                x1, y1, z1,
 
                 rayOrigin.x,
                 rayOrigin.y,

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