@woosh/meep-engine 2.34.47 → 2.35.0

package/engine/graphics/micron/render/instanced/AttributeDataTexture.js

@@ -3,55 +3,11 @@ import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
 import { DataTexture, NearestFilter } from "three";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
 import { compute_micron_buffer_array_constructor } from "../../build/compute_micron_buffer_array_constructor.js";
 import { computeThreeTextureTypeFromDataType } from "../../../render/forward_plus/data/computeThreeTextureTypeFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "../../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
 import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
-
-/**
- *
- * @returns {string}
- * @param {DataType} dt
- * @param {number} channel_count
- */
-function normalized_internal_format(dt, channel_count) {
-    let suffix = '';
-    switch (dt) {
-        case DataType.Uint8:
-            suffix = '8';
-            break;
-        case DataType.Int8:
-            suffix = '8_SNORM';
-            break;
-        case DataType.Uint16:
-            suffix = '16UI';
-            break;
-        default:
-            throw new Error(`Unsupported data type '${dt}'`);
-    }
-
-    let prefix = '';
-
-    switch (channel_count) {
-        case 1:
-            prefix = 'R';
-            break;
-        case 2:
-            prefix = 'RG';
-            break;
-        case 3:
-            prefix = 'RGB';
-            break;
-        case 4:
-            prefix = 'RGBA';
-            break;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-
-    return prefix + suffix;
-}
+import { normalized_internal_format } from "../../../texture/normalized_internal_format.js";
 
 export class AttributeDataTexture {
     /**

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -132,15 +132,16 @@ export class ThreeInstancedAdapter {
 
     /**
      *
-     * @param {MicronGeometryPatchOccurrence[]} patches
+     * @param {Uint32Array[]} patches
      * @param {number} patch_count
+     * @param {VirtualGeometry} virtual_geometry
      */
-    build(patches, patch_count) {
+    build(patches, patch_count, virtual_geometry) {
         this.__prepare_capacity(patch_count);
 
         const geo = this.__buffer_geometry;
 
-        const patch_transform_attribute = geo.getAttribute(ATTRIBUTE_NAME_TRANSFORM);
+        const patch_transform_attribute = geo.attributes[ATTRIBUTE_NAME_TRANSFORM];
         /**
          *
          * @type {Float32Array}
@@ -149,21 +150,31 @@ export class ThreeInstancedAdapter {
 
         patch_transform_attribute.needsUpdate = true;
 
-        const patch_address_attribute = geo.getAttribute(ATTRIBUTE_NAME_ADDRESS);
+        const patch_address_attribute = geo.attributes[ATTRIBUTE_NAME_ADDRESS];
         const patch_address_array = patch_address_attribute.array;
 
         patch_address_attribute.needsUpdate = true;
 
         const patch_data = this.__patch_data;
+        const transforms = virtual_geometry.lookup_instance_transforms;
+        const geometries = virtual_geometry.loolup_geometries;
 
         for (let i = 0; i < patch_count; i++) {
-            const occurrence = patches[i];
+            const i3 = i * 3;
+
+            const instance_id = patches[i3];
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const transform = transforms[instance_id];
+            const micron_geometry = geometries[geometry_id];
+            const patch = micron_geometry.patches[patch_id];
 
             const i16 = i * 16;
 
-            patch_transform_array.set(occurrence.transform, i16);
+            patch_transform_array.set(transform, i16);
 
-            const patch_slot_id = patch_data.ensure(occurrence.patch);
+            const patch_slot_id = patch_data.ensure(patch);
 
             patch_address_array[i] = patch_slot_id;
         }

package/engine/graphics/micron/render/refinement/RefinementSpec.js

@@ -37,7 +37,6 @@ export class RefinementSpec {
          */
         const array_buffer = new ArrayBuffer(160);
 
-
         /**
          * Contains transformation from camera space to object space
          * @type {Float32Array|number[]|mat4}
@@ -50,17 +49,6 @@ export class RefinementSpec {
          * @type {Float32Array}
          */
         this.frustum_f32 = new Float32Array(array_buffer, 64, 24);
-
-
-        /**
-         * Object-space camera position
-         * @type {Float32Array}
-         */
-        this.view_position = new Float32Array(3);
-    }
-
-    get frustum() {
-        throw new Error('deprecated, use .frustum_f32 instead');
     }
 
     /**

package/engine/graphics/micron/render/refinement/get_geometry_patch_cut.js

@@ -0,0 +1,118 @@
+import { BitSet } from "../../../../../core/binary/BitSet.js";
+import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
+import { aabb3_estimate_projected_area2 } from "../../../../../core/geom/3d/aabb/aabb3_estimate_projected_area2.js";
+
+
+/**
+ *
+ * @type {BitSet}
+ */
+const scratch_traversal_bitset = new BitSet();
+scratch_traversal_bitset.preventShrink();
+
+/**
+ * Using a pre-allocated continuous chunk of memory gets us better cache coherence
+ * @readonly
+ * @type {number[]}
+ */
+const scratch_traversal_stack = new Uint32Array(781250);
+
+/**
+ *
+ * @param {VirtualGeometry} destination
+ * @param {RefinementSpec} spec
+ * @param {MicronGeometry} geometry
+ * @param instance_id
+ * @param transform
+ */
+export function get_geometry_patch_cut(
+    destination,
+    spec,
+    geometry,
+    instance_id,
+    transform
+) {
+
+    const frustum_planes = spec.frustum_f32;
+    const projection_matrix = spec.projection_matrix;
+    const error_threshold = spec.error_threshold_normalized;
+
+    const geometry_id = geometry.id;
+
+    let output_patch_cursor = destination.patch_count;
+
+    let i;
+    let stack_cursor = 1;
+
+    // initialize stack
+    const stack = scratch_traversal_stack;
+    const root = geometry.root;
+    stack[0] = root.id;
+
+    const included_set = scratch_traversal_bitset;
+    included_set.reset();
+
+    included_set.set(root.id, true);
+
+    const patches = geometry.patches;
+    const destination_patches = destination.patches;
+
+    while (stack_cursor > 0) {
+        stack_cursor--;
+
+        const patch_id = stack[stack_cursor];
+        const patch = patches[patch_id];
+
+        /*
+         check if node is in view frustum
+         NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
+         */
+        const in_view_frustum = aabb3_intersects_frustum_array(patch.bounding_box, frustum_planes);
+
+        if (!in_view_frustum) {
+            continue;
+        }
+
+        // check if record needs to be split
+        if (patch.lod > 0) {
+
+            // not the lowest level of LOD, see if subdivision might be necessary
+
+            // compute average triangle area
+            // const group_screen_area = aabb3_project_to_2d(patch.group_bounding_box_corners, projection_matrix);
+            const group_screen_area = aabb3_estimate_projected_area2(patch.group_bounding_box, projection_matrix);
+            const screen_space_error = patch.group_error * group_screen_area;
+
+            if (screen_space_error > error_threshold) {
+                // error too large, needs to be split
+
+                const children = patch.children;
+                const child_count = children.length;
+
+                for (i = 0; i < child_count; i++) {
+                    const child = children[i];
+
+                    if (included_set.getAndSet(child.id)) {
+                        continue;
+                    }
+
+                    stack[stack_cursor++] = child.id;
+                }
+
+                continue;
+            }
+        }
+
+
+        const target_address = output_patch_cursor * 3;
+
+        destination_patches[target_address] = instance_id;
+        destination_patches[target_address + 1] = geometry_id;
+        destination_patches[target_address + 2] = patch_id;
+
+        output_patch_cursor++;
+
+    }
+
+    destination.patch_count = output_patch_cursor;
+}

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -144,8 +144,9 @@ export class MaterialContext {
 
     /**
      *
+     * @param {VirtualGeometry} virtual_geometry
      */
-    build() {
+    build(virtual_geometry) {
 
         if (this.__patch_count === 0) {
             this.mesh.visible = false;
@@ -154,7 +155,7 @@ export class MaterialContext {
             this.mesh.visible = true;
         }
 
-        this.adapter.build(this.__patches, this.__patch_count);
+        this.adapter.build(this.__patches, this.__patch_count, virtual_geometry);
 
     }
 }

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -16,6 +16,7 @@ const scratch_mvc = new MaterialVertexSpec();
 export class VGThreeRenderer {
     constructor() {
         this.geometry = new VirtualGeometry();
+
         this.builder = new VirtualGeometryBuilder();
 
         /**
@@ -158,6 +159,10 @@ export class VGThreeRenderer {
         const contexts = this.__contexts_array;
         const context_count = contexts.length;
 
+        /**
+         *
+         * @type {Map<number, MaterialContext>}
+         */
         const instance_to_ctx = new Map();
 
         for (let i = 0; i < context_count; i++) {
@@ -175,18 +180,28 @@ export class VGThreeRenderer {
         const patches = geometry.patches;
 
         for (let i = 0; i < patch_count; i++) {
-            const patch = patches[i];
+            const i3 = i * 3;
+
+            const instance_id = patches[i3];
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const ctx = instance_to_ctx.get(instance_id);
+
+            const target_address = ctx.__patch_count * 3;
 
-            const ctx = instance_to_ctx.get(patch.instance_id);
+            ctx.__patches[target_address] = instance_id;
+            ctx.__patches[target_address + 1] = geometry_id;
+            ctx.__patches[target_address + 2] = patch_id;
 
-            ctx.__patches[ctx.__patch_count++] = patch;
+            ctx.__patch_count++;
         }
 
         // build each context
         for (let i = 0; i < context_count; i++) {
             const ctx = contexts[i];
 
-            ctx.build();
+            ctx.build(this.geometry);
         }
     }
 

package/engine/graphics/render/utils/ThreeBypassRenderer.js

@@ -72,8 +72,9 @@ export class ThreeBypassRenderer {
 
         let stack_top = 0;
         let j = 0;
+        let i = 0;
 
-        for (let i = 0; i < input_size; i++) {
+        for (; i < input_size; i++) {
             const object3D = input[i];
 
             if (input_filter(object3D)) {
@@ -119,7 +120,7 @@ export class ThreeBypassRenderer {
             const children = object3D.children;
             const child_count = children.length;
 
-            for (let i = 0; i < child_count; i++) {
+            for (i = 0; i < child_count; i++) {
                 const child = children[i];
 
                 stack[stack_top++] = child;

package/engine/graphics/texture/normalized_internal_format.js

@@ -0,0 +1,48 @@
+import { DataType } from "../../../core/collection/table/DataType.js";
+import { assert } from "../../../core/assert.js";
+
+/**
+ *
+ * @returns {string}
+ * @param {DataType} dt
+ * @param {number} channel_count
+ */
+export function normalized_internal_format(dt, channel_count) {
+    assert.isNonNegativeInteger(channel_count, 'channel_count');
+
+    let suffix = '';
+    switch (dt) {
+        case DataType.Uint8:
+            suffix = '8';
+            break;
+        case DataType.Int8:
+            suffix = '8_SNORM';
+            break;
+        case DataType.Uint16:
+            suffix = '16UI';
+            break;
+        default:
+            throw new Error(`Unsupported data type '${dt}'`);
+    }
+
+    let prefix = '';
+
+    switch (channel_count) {
+        case 1:
+            prefix = 'R';
+            break;
+        case 2:
+            prefix = 'RG';
+            break;
+        case 3:
+            prefix = 'RGB';
+            break;
+        case 4:
+            prefix = 'RGBA';
+            break;
+        default:
+            throw new Error(`Unsupported channel count '${channel_count}'`);
+    }
+
+    return prefix + suffix;
+}

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

@@ -1555,3 +1555,9 @@ Sampler2D.prototype.traverseOrthogonalNeighbours = function (x, y, visitor, this
     }
 };
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Sampler2D.prototype.isSampler2D = true;
+

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

@@ -0,0 +1,25 @@
+//
+
+/**
+ * Copy single channel from one sampler to another
+ * @param {Sampler2D} source
+ * @param {number} source_channel
+ * @param {Sampler2D} destination
+ * @param {number} destination_channel
+ */
+export function sampler2d_copy_channel_data(source, source_channel, destination, destination_channel) {
+    const pixel_count = source.height * source.width;
+
+    const source_item_size = source.itemSize;
+    const destination_item_size = destination.itemSize;
+
+    const source_data = source.data;
+    const destination_data = destination.data;
+
+    for (let i = 0; i < pixel_count; i++) {
+        const address_source = i * source_item_size + source_channel;
+        const address_destination = i * destination_item_size + destination_channel;
+
+        destination_data[address_destination] = source_data[address_source];
+    }
+}

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

@@ -10,6 +10,9 @@ import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
  * @param {Sampler2D} output
  */
 export function scaleSampler2D(input, output) {
+    assert.equal(input.isSampler2D, true, 'input.isSampler2D !== true');
+    assert.equal(output.isSampler2D, true, 'output.isSampler2D !== true');
+
     const targetItemSize = output.itemSize;
 
     assert.equal(input.itemSize, targetItemSize, 'both source and target must have the same number of channels');

package/engine/graphics/texture/sampler/util/drawSamplerHTML.js

@@ -16,7 +16,20 @@ import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInsta
 export function drawSamplerHTML(parentNode, sampler, x, y, scale, offset, size) {
 
 
-    const target = new Sampler2D(typedArrayConstructorByInstance(sampler.data), sampler.itemSize, size, size);
+    const TA = typedArrayConstructorByInstance(sampler.data);
+
+
+    let target_width = size;
+    let target_height = size;
+
+    // apply aspect ratio
+    if (sampler.width > sampler.height) {
+        target_height = Math.ceil(size * (sampler.height / sampler.width));
+    } else if (sampler.width < sampler.height) {
+        target_width = Math.ceil(size * (sampler.width / sampler.height));
+    }
+
+    const target = new Sampler2D(new TA(target_width * target_height * sampler.itemSize), sampler.itemSize, target_width, target_height);
 
     scaleSampler2D(sampler, target);
 

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