@woosh/meep-engine 2.33.76 → 2.34.3

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -13,6 +13,9 @@ import { build_geometry_info } from "./build_geometry_info.js";
 import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.js";
 import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compute_buffer_geometry_byte_size.js";
 import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
+import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
+import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../core/math/max2.js";
 
 /**
  * Returns current time in milliseconds
@@ -100,6 +103,38 @@ function attributes_from_buffer_geometry(buffer_geometry) {
 
 const PRINT_VERBOSE_STATS = false;
 
+/**
+ *
+ * @param {AABB3} result
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_length
+ */
+function aabb3_from_v3_array(result, input, input_length) {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let z0 = Infinity;
+
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    let z1 = -Infinity;
+
+    for (let i = 0; i < input_length; i += 3) {
+        const x = input[i];
+        const y = input[i + 1];
+        const z = input[i + 2];
+
+        x0 = min2(x, x0);
+        y0 = min2(y, y0);
+        z0 = min2(z, z0);
+
+        x1 = max2(x, x1);
+        y1 = max2(y, y1);
+        z1 = max2(z, z1);
+    }
+
+    result.setBounds(x0, y0, z0, x1, y1, z1);
+}
+
 /**
  *
  * @param {THREE.BufferGeometry} input
@@ -118,7 +153,12 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
     const vertex_position_array = position_attribute.array;
 
     topoMesh.build(vertex_position_array, face_index_array);
-    expandConnectivityByLocality(topoMesh);
+
+    // compute aabb
+    const geometry_aabb = new AABB3();
+    aabb3_from_v3_array(geometry_aabb, vertex_position_array, vertex_position_array.length);
+
+    expandConnectivityByLocality(topoMesh, geometry_aabb);
 
     /**
      * Used to generate neighbourhood assignment

package/engine/graphics/micron/format/MicronGeometry.d.ts

@@ -1,9 +1,15 @@
 import {BufferGeometry} from "three";
 import {VertexDataSpec} from "../../geometry/VertexDataSpec";
+import {SurfacePoint3} from "../../../../core/geom/3d/SurfacePoint3";
 
 export class MicronGeometry {
     vertex_spec: VertexDataSpec
     public proxy: BufferGeometry
 
     initialize(): void
+
+    raycast(
+        origin_x: number, origin_y: number, origin_z: number,
+        direction_x: number, direction_y: number, direction_z: number
+    ): SurfacePoint3[]
 }

package/engine/graphics/micron/format/MicronGeometry.js

@@ -1,5 +1,8 @@
 import { VertexDataSpec } from "../../geometry/VertexDataSpec.js";
 import { assert } from "../../../../core/assert.js";
+import { intersectRay } from "../../../../core/bvh2/aabb3/AABB3Math.js";
+import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 
 let id_counter = 0;
 
@@ -55,6 +58,151 @@ export class MicronGeometry {
         this.__proxy = null;
     }
 
+    /**
+     *
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @returns {SurfacePoint3[]}
+     */
+    raycast(
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z
+    ) {
+
+        /**
+         *
+         * @type {SurfacePoint3[]}
+         */
+        const hits = [];
+
+        let stack_cursor = 1;
+        const stack = [this.root];
+
+        const spec = this.vertex_spec;
+
+        const position_attribute_index = spec.getAttributeIndexByName('position');
+
+        // check that position attribute actually exists
+        assert.isNonNegativeInteger(position_attribute_index, 'position_attribute_index');
+
+        const temp_hit = new SurfacePoint3();
+
+        while (stack_cursor > 0) {
+            stack_cursor--;
+
+            const patch = stack[stack_cursor];
+
+            // using group bounding box because it's conservative, as we want to be able to hit LOD_0
+            const bb = patch.group_bounding_box;
+
+            const bb_intersection_exists = intersectRay(
+                bb[0], bb[1], bb[2], bb[3], bb[4], bb[5],
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
+
+            if (!bb_intersection_exists) {
+                // no intersection
+                continue;
+            }
+
+            if (patch.lod === 0) {
+                // LOD 0 - source geometry
+
+                // raycast against geometry
+                const indices = patch.face_indices;
+                const index_count = indices.length;
+
+                const vertices = patch.vertex_attribute_arrays[position_attribute_index];
+
+                for (let i = 0; i < index_count;) {
+                    const a = indices[i++];
+                    const b = indices[i++];
+                    const c = indices[i++];
+
+
+                    const a_address = a * 3;
+                    const b_address = b * 3;
+                    const c_address = c * 3;
+
+
+                    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(
+                        temp_hit,
+                        origin_x, origin_y, origin_z,
+                        direction_x, direction_y, direction_z,
+                        ax, ay, az,
+                        bx, by, bz,
+                        cx, cy, cz
+                    )) {
+
+                        const contact = new SurfacePoint3();
+
+                        contact.copy(temp_hit);
+
+                        hits.push(contact);
+
+                    }
+                }
+
+            } else {
+                // refine more
+                const children = patch.children;
+
+                const child_count = children.length;
+
+                for (let i = 0; i < child_count; i++) {
+                    const child = children[i];
+
+                    // push to stack
+                    stack[stack_cursor] = child;
+
+                    stack_cursor++;
+                }
+            }
+        }
+
+        return hits;
+    }
+
+    /**
+     *
+     * @param {number} lod
+     * @returns {number}
+     */
+    computeLodFaceCount(lod) {
+        let r = 0;
+
+        const patches = this.patches;
+        const patch_count = patches.length;
+        for (let i = 0; i < patch_count; i++) {
+            const patch = patches[i];
+
+            if (patch.lod !== lod) {
+                continue;
+            }
+
+            r += patch.polygon_count;
+        }
+
+        return r;
+    }
+
     get patches() {
         return this.__patches;
     }
@@ -84,17 +232,21 @@ export class MicronGeometry {
 
     /**
      * Build geometry proxy from the patches
-     * @param {number} percent percentage of the original geometry to keep
+     * @param {number} fraction percentage of the original geometry to keep
+     * @param {number} min minimum number of triangles to keep, this will be respected first before percentage value
      */
-    buildProxy(percent) {
+    buildProxy(fraction, min) {
         throw new Error('Not Implemented');
     }
 
     computeByteSize() {
         let result = 0;
 
-        for (let i = 0; i < this.__patches.length; i++) {
-            result += this.__patches[i].computeByteSize();
+        const patches = this.__patches;
+        const patch_count = patches.length;
+
+        for (let i = 0; i < patch_count; i++) {
+            result += patches[i].computeByteSize();
         }
 
         return result;

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

@@ -98,7 +98,16 @@ class GLTFAssetTransformer extends AssetTransformer {
 
         const base = computePathDirectory(ad.path);
 
-        const micron_data = await this.__am.promise(`${base}/${micron_uri}`, ASSET_TYPE_ARRAY_BUFFER);
+        let micron_data;
+
+        const micron_path = `${base}/${micron_uri}`;
+
+        try {
+            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
+        } catch (e) {
+            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
+            return;
+        }
 
         // deserialize micron data
         const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());

package/engine/graphics/particles/particular/engine/parameter/ParticleParameter.js

@@ -173,8 +173,12 @@ export class ParticleParameter {
         //lock default track
         this.defaultTrackValue.disableWriteMode();
 
-        for (i = 0; i < this.trackCount; i++) {
-            track = this.tracks.get(i);
+        const track_count = this.trackCount;
+        const tracks = this.tracks;
+
+        for (i = 0; i < track_count; i++) {
+
+            track = tracks.get(i);
 
             if (track === undefined) {
                 //write the default track into the parameter
@@ -183,6 +187,7 @@ export class ParticleParameter {
                 //lock track
                 track.disableWriteMode();
             }
+
         }
 
         this.computeStatistics();

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

@@ -433,9 +433,10 @@ 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_micron_conveted/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)
+    // load_model('moicon/test_philippe_jan_2022/test/model.gltf', ecd)
 
     const P_SIZE_SMALL = 0.15;
     const P_SIZE_MEDIUM = 0.6;

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -30,13 +30,19 @@ export function query_bvh_frustum_from_texture(
     let result = 0;
     let plane_address;
 
+    const binary_node_count = root.getBinaryNodeCount();
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
     stack[0] = 0;
 
-    const binary_node_count = root.getBinaryNodeCount();
     const last_valid_index = binary_node_count + root.getLeafNodeCount();
     const data_view = root.getDataView();
 
@@ -122,8 +128,6 @@ export function query_bvh_frustum_from_texture(
 
             } else if (light_type === 3) {
                 // decal
-                debugger;
-
             } else {
                 throw new Error(`Unsupported light type ${light_type}`);
             }

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

@@ -1374,6 +1374,8 @@ Sampler2D.prototype.traverseCircle = function (centerX, centerY, radius, visitor
  * @param {boolean} [preserveData=true]
  */
 Sampler2D.prototype.resize = function (x, y, preserveData = true) {
+    assert.isNonNegativeInteger(x, 'x');
+    assert.isNonNegativeInteger(y, 'y');
 
     const _w = this.width;
     const _h = this.height;

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

@@ -56,9 +56,11 @@ export function downsampleSampler2D(input, output) {
 
             // accumulate sample
             for (j = 0; j < sH; j++) {
+                const row_index = (sampleOffsetY + j) * iW;
+
                 for (i = 0; i < sW; i++) {
 
-                    const iAddress = ((sampleOffsetX + i) + (sampleOffsetY + j) * iW) * itemSize;
+                    const iAddress = ((sampleOffsetX + i) + row_index) * itemSize;
 
                     for (k = 0; k < itemSize; k++) {
                         sample[k] += iData[k + iAddress];

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

@@ -0,0 +1,67 @@
+import { max2 } from "../../../../core/math/max2.js";
+
+/**
+ *
+ * @param {Sampler2D} source
+ * @param {Sampler2D} target
+ */
+export function genericResampleSampler2D(source, target) {
+    const target_width = target.width;
+    const target_height = target.height;
+
+    // build kernel
+
+    // TODO add gaussian weights kernel for samples
+
+    const u_scale = source.width / target_width;
+    const v_scale = source.height / target_height;
+
+    const kernel_width = max2(1, Math.ceil(u_scale));
+    const kernel_height = max2(1, Math.ceil(v_scale));
+
+    const kernel_size = kernel_width * kernel_height;
+
+    const itemSize = source.itemSize;
+
+    const sample = new Float32Array(itemSize);
+
+    let column_index;
+    let row_index;
+    let k_y;
+    let k_x;
+    let i;
+
+    for (column_index = 0; column_index < target_height; column_index++) {
+        for (row_index = 0; row_index < target_width; row_index++) {
+
+            // figure out source offset
+            const source_x = row_index * u_scale;
+            const source_y = column_index * v_scale;
+
+            // reset sample
+            for (i = 0; i < itemSize; i++) {
+                sample[i] = 0;
+            }
+
+            // accumulate kernel samples
+            for (k_y = 0; k_y < kernel_height; k_y++) {
+
+                for (k_x = 0; k_x < kernel_width; k_x++) {
+
+                    for (i = 0; i < itemSize; i++) {
+                        sample[i] += source.sampleChannelBilinear(source_x + k_x, source_y + k_y, i);
+                    }
+
+                }
+            }
+
+            for (i = 0; i < itemSize; i++) {
+                // dilute sample
+                const channel_value = sample[i] / kernel_size;
+                // write out
+                target.data[(column_index * target_width + row_index) * itemSize + i] = channel_value;
+            }
+
+        }
+    }
+}

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

@@ -1,47 +1,41 @@
 import { assert } from "../../../../core/assert.js";
+import { downsampleSampler2D } from "./downsampleSampler2D.js";
+import { Sampler2D } from "./Sampler2D.js";
+import { upsampleSampler2D } from "./upsampleSampler2D.js";
+import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
 
 /**
  *
- * @param {Sampler2D} source
- * @param {Sampler2D} target
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
  */
-export function scaleSampler2D(source, target) {
-    const targetItemSize = target.itemSize;
+export function scaleSampler2D(input, output) {
+    const targetItemSize = output.itemSize;
 
-    assert.equal(source.itemSize, targetItemSize, 'both source and target must have the same number of channels');
+    assert.equal(input.itemSize, targetItemSize, 'both source and target must have the same number of channels');
 
-    const targetWidth = target.width;
-    const targetHeight = target.height;
-    const sourceWidth = source.width;
-    const sourceHeight = source.height;
-
-
-    const target_data = target.data;
+    const targetWidth = output.width;
+    const targetHeight = output.height;
+    const sourceWidth = input.width;
+    const sourceHeight = input.height;
 
     if (sourceWidth === targetWidth && sourceHeight === targetHeight) {
-        // exact size match, nothing to do
-        target_data.set(source.data);
-        return;
-    }
-
-    const targetRowSize = targetItemSize * targetWidth;
-
-    const source_scale_x = sourceWidth / targetWidth;
-    const source_scale_y = sourceHeight / targetHeight;
-
-    for (let y = 0; y < targetHeight; y++) {
-
-
-        const sample_y = y * source_scale_y;
-        const target_row_address = y * targetRowSize;
-
-        for (let x = 0; x < targetWidth; x++) {
-
-
-            const target_offset = target_row_address + x * targetItemSize;
-
-            source.sampleBilinear(x * source_scale_x, sample_y, target_data, target_offset);
-
+        // same dimensions, copy directly
+        output.data.set(input.data);
+    } else if (sourceWidth > targetWidth && sourceHeight > targetHeight) {
+        // downscaling
+        if (Number.isInteger(sourceWidth / targetWidth) && Number.isInteger(sourceHeight / targetHeight)) {
+            // dimensions are multiples of source/target
+            downsampleSampler2D(input, output);
+        } else {
+            // generic downsample
+            genericResampleSampler2D(input, output);
         }
+    } else if (sourceWidth < targetWidth && sourceHeight < targetHeight) {
+        // upscaling
+        upsampleSampler2D(input, output);
+    } else {
+        // mixed resampling
+        genericResampleSampler2D(input, output);
     }
 }

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

@@ -0,0 +1,47 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
+ */
+export function upsampleSampler2D(input, output) {
+    const targetItemSize = output.itemSize;
+
+    assert.equal(input.itemSize, targetItemSize, 'both source and target must have the same number of channels');
+
+    const targetWidth = output.width;
+    const targetHeight = output.height;
+    const sourceWidth = input.width;
+    const sourceHeight = input.height;
+
+
+    const target_data = output.data;
+
+    if (sourceWidth === targetWidth && sourceHeight === targetHeight) {
+        // exact size match, nothing to do
+        target_data.set(input.data);
+        return;
+    }
+
+    const targetRowSize = targetItemSize * targetWidth;
+
+    const source_scale_x = sourceWidth / targetWidth;
+    const source_scale_y = sourceHeight / targetHeight;
+
+    for (let y = 0; y < targetHeight; y++) {
+
+
+        const sample_y = y * source_scale_y;
+        const target_row_address = y * targetRowSize;
+
+        for (let x = 0; x < targetWidth; x++) {
+
+
+            const target_offset = target_row_address + x * targetItemSize;
+
+            input.sampleBilinear(x * source_scale_x, sample_y, target_data, target_offset);
+
+        }
+    }
+}

package/generation/filtering/numeric/CellFilterReadGridLayer.js

@@ -36,8 +36,8 @@ export class CellFilterReadGridLayer extends CellFilter {
         // cache required values
         this.__sampler = this.__layer.sampler;
 
-        this.__u_scale = grid.width / this.__sampler.width;
-        this.__v_scale = grid.height / this.__sampler.height;
+        this.__u_scale = this.__sampler.width / grid.width;
+        this.__v_scale = this.__sampler.height / grid.height;
     }
 
     /**

package/generation/filtering/numeric/math/CellFilterSaturate.js

@@ -0,0 +1,24 @@
+import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
+import { clamp } from "../../../../core/math/clamp.js";
+import { assert } from "../../../../core/assert.js";
+
+export class CellFilterSaturate extends CellFilterUnaryOperation {
+    operation(v) {
+        return clamp(v, 0, 1);
+    }
+
+    /**
+     *
+     * @param {CellFilter} v
+     * @return {CellFilterUnaryOperation}
+     */
+    static from(v) {
+        assert.equal(v.isCellFilter, true, "v.isCellFilter !== true");
+
+        const r = new CellFilterSaturate();
+
+        r.source = v;
+
+        return r;
+    }
+}

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