@woosh/meep-engine 2.33.62 → 2.33.67

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

@@ -13,6 +13,13 @@ import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteH
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
 import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
 import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
+import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
+import { computePathDirectory } from "../../../../core/FilePath.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../format/MicronGeometry.js";
+import { ArrayBufferLoader } from "../../../asset/loaders/ArrayBufferLoader.js";
+import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
+import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
 
 /**
  *
@@ -20,6 +27,7 @@ import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper
  */
 const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
 
+const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
 class GLTFAssetTransformer extends AssetTransformer {
     /**
@@ -35,17 +43,100 @@ class GLTFAssetTransformer extends AssetTransformer {
          * @private
          */
         this.__cache = cache;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
+
+        /**
+         *
+         * @type {MicronGeometryBinarySerializationAdapter}
+         * @private
+         */
+        this.__serde = new MicronGeometryBinarySerializationAdapter();
     }
 
-    async transform(source) {
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
+    }
+
+
+    /**
+     * @param {THREE.Object3D} object
+     * @param {{asset:AssetDescription}} ctx
+     * @return {Promise<void>}
+     * @private
+     */
+    async __visitObjectToLoadMicron(object, ctx) {
+        if (!object.isMesh) {
+            return;
+        }
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        const geometry = object.geometry;
+
+        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+
+        if (typeof micron_uri !== "string") {
+            return;
+        }
+
+
+        /**
+         * @type {AssetDescription}
+         */
+        const ad = ctx.asset;
+
+        const base = computePathDirectory(ad.path);
+
+        const micron_data = await this.__am.promise(`${base}/${micron_uri}`, ASSET_TYPE_ARRAY_BUFFER);
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        const micron_geometry = new MicronGeometry();
+
+        this.__serde.deserialize(buffer, micron_geometry);
+
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+    }
+
+
+    /**
+     *
+     * @param {Asset} source
+     * @param asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
         const animationClips = source.animations;
+
         if (animationClips !== undefined && animationClips.length > 0) {
             // not suitable
             return source;
         }
 
+        /**
+         * @type {THREE.Object3D}
+         */
         const root = source.create();
 
+        // attempt to load existing micron geometries
+        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+            asset: asset_description
+        });
+
         const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
         micron_root.boundingSphere = root.boundingSphere;
 
@@ -117,7 +208,7 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         /**
          *
-         * @type {AssetTransformer}
+         * @type {GLTFAssetTransformer}
          * @private
          */
         this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
@@ -180,8 +271,17 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         const engine = this.engine;
 
-        engine.assetManager.registerTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.registerTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        // ensure that "arraybuffer" asset loader is present
+        if (am.getLoaderByType(ASSET_TYPE_ARRAY_BUFFER) === undefined) {
+            am.registerLoader(ASSET_TYPE_ARRAY_BUFFER, new ArrayBufferLoader());
+        }
+
+        this.__asset_transformer.assetManager = am;
+
+        am.registerTransformer("model/gltf", this.__asset_transformer);
+        am.registerTransformer("model/gltf+json", this.__asset_transformer);
 
         /**
          *
@@ -207,8 +307,12 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         this.__persisted_geometry.detach_storage();
 
-        engine.assetManager.unregisterTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        am.unregisterTransformer("model/gltf", this.__asset_transformer);
+        am.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+
+        this.__asset_transformer.assetManager = null;
 
         const ge = engine.graphics;
 

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -42,7 +42,6 @@ import { RepeatBehavior } from "../../../../../../intelligence/behavior/decorato
 import { ActionBehavior } from "../../../../../../intelligence/behavior/primitive/ActionBehavior.js";
 import { pingpong } from "../../../../../../../core/math/pingpong.js";
 import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
-import { pick } from "../../../../../../../../model/game/util/ScreenGridPicker.js";
 import GUIElement from "../../../../../../ecs/gui/GUIElement.js";
 import EmptyView from "../../../../../../../view/elements/EmptyView.js";
 import HeadsUpDisplay from "../../../../../../ecs/gui/hud/HeadsUpDisplay.js";
@@ -77,6 +76,7 @@ import TopDownCameraController from "../../../../../ecs/camera/topdown/TopDownCa
 import { randomFloatBetween } from "../../../../../../../core/math/random/randomFloatBetween.js";
 import { MicronRenderPlugin } from "../../../../../micron/plugin/MicronRenderPlugin.js";
 import { obtainTerrain } from "../../../../../../ecs/terrain/util/obtainTerrain.js";
+import { pick } from "../../../../../../../ecs/grid/pick.js";
 
 const engineHarness = new EngineHarness();
 
@@ -433,7 +433,9 @@ async function sample_scene_nam(engine) {
         "distanceMax": 1000
     });
 
-    load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    // load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
+    // load_model('moicon/micron_container/model.gltf', ecd)
 
     const P_SIZE_SMALL = 0.15;
     const P_SIZE_MEDIUM = 0.6;

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -80,7 +80,7 @@ import { ParticleEmitterSystem } from "../../../particles/ecs/ParticleEmitterSys
 import { ShadedGeometrySystem } from "../../../ecs/mesh-v2/ShadedGeometrySystem.js";
 import { FogOfWar } from "../../../../ecs/fow/FogOfWar.js";
 import { FogOfWarRevealer } from "../../../../ecs/fow/FogOfWarRevealer.js";
-import Team from "../../../../../../model/game/ecs/component/Team.js";
+import Team from "../../../../ecs/team/Team.js";
 import { AmbientOcclusionPostProcessEffect } from "../../buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 import { obtainTerrain } from "../../../../ecs/terrain/util/obtainTerrain.js";
 

package/engine/graphics/render/webgpu/sample/MeshInstance.js

@@ -1,5 +1,7 @@
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 
+const BIND_GROUP_MATERIAL = 1;
+
 export class MeshInstance {
     constructor() {
 
@@ -9,6 +11,12 @@ export class MeshInstance {
          */
         this.geometry = null;
 
+        /**
+         *
+         * @type {null}
+         */
+        this.material = null;
+
         /**
          *
          * @type {GPUBuffer|null}
@@ -75,13 +83,26 @@ export class MeshInstance {
 
     }
 
+    /**
+     *
+     * @param {GPURenderPassEncoder} pass
+     */
+    preparePass(pass) {
+
+    }
+
     /**
      *
      * @param {GPURenderPassEncoder} pass
      */
     draw(pass) {
+        // set material bindings
+
+        // pass.setBindGroup(BIND_GROUP_MATERIAL, {});
+
         pass.setVertexBuffer(0, this.vertex_buffer);
         pass.setIndexBuffer(this.index_buffer, 'uint32');
+
         pass.drawIndexed(this.geometry.getIndex().array.length);
     }
 }

package/engine/graphics/render/webgpu/sample/main.js

@@ -323,7 +323,7 @@ const init = async ({ canvasRef, gui }) => {
     };
     const settings = {
         mode: 'rendering',
-        numLights: 128,
+        numLights:1,
     };
     const configUniformBuffer = (() => {
         const buffer = device.createBuffer({
@@ -541,7 +541,7 @@ const init = async ({ canvasRef, gui }) => {
             gBufferPass.setPipeline(writeGBuffersPipeline);
             gBufferPass.setBindGroup(0, sceneUniformBindGroup);
 
-            m_instance.draw(gBufferPass);
+                m_instance.draw(gBufferPass);
 
             gBufferPass.endPass();
         }

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;