@woosh/meep-engine 2.34.30 → 2.34.34

package/core/assert.js

@@ -316,6 +316,17 @@ assert.defined = function (value, name = "value") {
 
 };
 
+/**
+ *
+ * @param {*} value
+ * @param {String} [name]
+ */
+assert.isNull = function (value, name){
+    if (value !== null) {
+        throw new Error(`${name} is NOT null`);
+    }
+}
+
 /**
  *
  * @param {*} value

package/core/bvh2/BinaryNode.js

@@ -8,7 +8,7 @@ import { arrayQuickSort } from "../collection/array/arrayQuickSort.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import { computeSampleStandardDeviation } from "../math/statistics/computeSampleStandardDeviation.js";
-import { aabb3_intersect_aabb3, boxSurfaceArea2 } from "./aabb3/AABB3Math.js";
+import { _boxSurfaceArea2, aabb3_intersect_aabb3, boxSurfaceArea2 } from "./aabb3/AABB3Math.js";
 import { isLeaf, LeafNode } from "./LeafNode.js";
 import { Node } from "./Node.js";
 import { surfaceAreaHeuristic } from "./sah/surfaceAreaHeuristic.js";
@@ -139,13 +139,135 @@ BinaryNode.prototype.setChildren = function (left, right) {
     right.parentNode = this;
 };
 
+/**
+ *
+ * @param {Node} child
+ */
+BinaryNode.prototype.setChildLeft = function (child) {
+    assert.isNull(this.left, 'left');
+
+    this.left = child;
+
+    this.updateLeafNodeCount();
+
+    this.refit();
+
+    child.parentNode = this;
+}
+
+/**
+ *
+ * @param {Node} child
+ */
+BinaryNode.prototype.setChildRight = function (child) {
+    assert.isNull(this.right, 'right');
+
+    this.right = child;
+
+    this.updateLeafNodeCount();
+
+    this.refit();
+
+    child.parentNode = this;
+}
+
+/**
+ * @see "Dynamic BVH" by Erin Catto / Blizzard
+ * @param {AABB3} node
+ * @param {AABB3} addition
+ * @returns {number}
+ */
+function inclusion_surface_area_heuristic(node, addition) {
+    const x0 = min2(node.x0, addition.x0);
+    const y0 = min2(node.y0, addition.y0);
+    const z0 = min2(node.z0, addition.z0);
+
+    const x1 = max2(node.x1, addition.x1);
+    const y1 = max2(node.y1, addition.y1);
+    const z1 = max2(node.z1, addition.z1);
+
+    return _boxSurfaceArea2(x0, y0, z0, x1, y1, z1) - boxSurfaceArea2(node);
+}
+
+/**
+ *
+ * @param {BinaryNode|LeafNode} node
+ * @param {AABB3} addition
+ */
+function inclusion_cost_lower_bound(node, addition) {
+    let n = node;
+    let r = boxSurfaceArea2(addition);
+
+    while (n !== null) {
+
+        r += n.costForInclusion(addition);
+
+        n = n.parentNode;
+    }
+
+    return r;
+}
+
+/**
+ * For incremental insertion, a sibling needs to be found, newly inserted node will be parented together with this sibling
+ * @param {AABB3} box
+ * @returns {BinaryNode|LeafNode}
+ */
+BinaryNode.prototype.__insertion_findSiblingFor = function (box) {
+
+    const open_set = [this];
+    let cursor = 1;
+
+    let best_cost = Infinity;
+    let best_node = this;
+
+    while (cursor > 0) {
+        const node = open_set[--cursor];
+
+        const cost = inclusion_surface_area_heuristic(node, box);
+
+        if (cost < best_cost) {
+            best_cost = cost;
+            best_node = node;
+        }
+
+        if (node.isBinaryNode) {
+
+            if (node.isProtected()) {
+                continue;
+            }
+
+            // consider pushing children into the queue
+
+            // compute lower bound for cost
+            const c_low = inclusion_cost_lower_bound(node, box);
+
+            if (c_low < best_cost) {
+                // worth-while to explore children
+                if (node.left !== null) {
+                    open_set[cursor++] = node.left;
+                }
+                if (node.right !== null) {
+                    open_set[cursor++] = node.right
+                }
+            }
+        }
+
+
+    }
+
+    return best_node;
+}
+
 /**
  *
  * @param {AABB3} box
- * @returns {Node}
+ * @returns {Node|BinaryNode|LeafNode}
  */
 BinaryNode.prototype.findParentFor = function (box) {
     let n = this;
+    let aCost = 0;
+    let bCost = 0;
 
     for (; ;) {
 
@@ -181,8 +303,8 @@ BinaryNode.prototype.findParentFor = function (box) {
             }
         }
 
-        let aCost = a.costForInclusion(box);
-        let bCost = b.costForInclusion(box);
+        aCost = a.costForInclusion(box);
+        bCost = b.costForInclusion(box);
 
         if (aCost === bCost) {
 
@@ -196,9 +318,9 @@ BinaryNode.prototype.findParentFor = function (box) {
 
             }
 
-            //change costs to be surface areas instead
-            aCost = a.computeSAH();
-            bCost = b.computeSAH();
+            //change costs to be based on balance
+            aCost = a.leafNodeCount / boxSurfaceArea2(a);
+            bCost = b.leafNodeCount / boxSurfaceArea2(b);
         }
 
         if (aCost === bCost) {
@@ -518,26 +640,29 @@ function countLeaves(node) {
 }
 
 /**
- *
+ * @deprecated Incorrect usage of SAH
  * @return {number}
  */
 BinaryNode.prototype.computeSAH = function () {
     let leftLeaves, rightLeaves, leftArea, rightArea;
 
-    if (this.left === null) {
+    const left = this.left;
+
+    if (left === null) {
         leftArea = 0;
         leftLeaves = 0;
     } else {
-        leftArea = boxSurfaceArea2(this.left);
-        leftLeaves = this.left.leafNodeCount;
+        leftArea = boxSurfaceArea2(left);
+        leftLeaves = left.leafNodeCount;
     }
 
-    if (this.right === null) {
+    const right = this.right;
+    if (right === null) {
         rightArea = 0;
         rightLeaves = 0;
     } else {
-        rightArea = boxSurfaceArea2(this.right);
-        rightLeaves = this.right.leafNodeCount;
+        rightArea = boxSurfaceArea2(right);
+        rightLeaves = right.leafNodeCount;
     }
 
     const thisArea = boxSurfaceArea2(this);
@@ -1065,34 +1190,96 @@ function transplantNewCommonParent(node, child) {
 
     parent.bubbleExpandToFit(bNode);
 
+    parent.updateLeafNodeCount();
+
     return bNode;
 }
 
+
 /**
  *
  * @param {Node|BinaryNode|LeafNode} child
  */
 BinaryNode.prototype.insertNode = function (child) {
-    assert.notEqual(child, null, "child node is null");
-    assert.notEqual(child, undefined, "child node is undefined");
-    assert.ok(child instanceof Node, undefined, "child node is not an instance of Node");
+
+    assert.notNull(child, "child");
+    assert.defined(child, "child");
+    assert.isInstanceOf(child, Node, 'child', "Node");
+    assert.equal(child.parentNode, null, "parentNode must be null, otherwise Node still belongs to another tree");
+
+    const sibling = this.__insertion_findSiblingFor(child);
+
+    const sibling_parent = sibling.parentNode;
+    if (sibling_parent === null) {
+        // root node
+
+        if (sibling.left === null) {
+            sibling.setChildLeft(child);
+        } else if (sibling.right === null) {
+            sibling.setChildRight(child);
+        } else {
+            const parent = new BinaryNode();
+
+            parent.setChildren(sibling.right, child);
+            sibling.right = parent;
+            parent.parentNode = sibling;
+        }
+
+    } else {
+
+        // non-root
+
+        if (sibling_parent.left === sibling && sibling_parent.right === null) {
+
+            // right node is free, take it
+            sibling_parent.setChildRight(child);
+
+        } else if (sibling_parent.right === sibling && sibling_parent.left === null) {
+
+            // left node is free, take it
+            sibling_parent.setChildLeft(child);
+
+        } else {
+
+            transplantNewCommonParent(sibling, child)
+
+        }
+
+        sibling_parent.bubbleRefit();
+
+    }
+}
+
+/**
+ * @deprecated
+ * @param {Node|BinaryNode|LeafNode} child
+ */
+BinaryNode.prototype.insertNode_old = function (child) {
+    assert.notNull(child, "child");
+    assert.defined(child, "child");
+    assert.isInstanceOf(child, Node, 'child', "Node");
     assert.equal(child.parentNode, null, "parentNode must be null, otherwise Node still belongs to another tree");
 
     const node = this.findParentFor(child);
 
     let bNode;
 
-    if (node.isBinaryNode) {
-        if ((node.isProtected() && node !== this)) {
-            transplantNewCommonParent(node, child);
-        } else if (node.left === null) {
+    if (
+        node.isBinaryNode &&
+        !(node.isProtected() && node !== this) // protected node, can't insert into this subtree
+    ) {
+
+        if (node.left === null) {
             node.left = child;
             child.parentNode = node;
             node.bubbleExpandToFit(child);
+
         } else if (node.right === null) {
+
             node.right = child;
             child.parentNode = node;
             node.bubbleExpandToFit(child);
+
         } else {
             //take right child and insert another binary node there
             bNode = new BinaryNode();
@@ -1106,18 +1293,17 @@ BinaryNode.prototype.insertNode = function (child) {
         node.updateLeafNodeCount();
     } else {
         //need to do transplanting and introduce a new common parent
-        bNode = transplantNewCommonParent(node, child);
+        transplantNewCommonParent(node, child);
 
-        bNode.updateLeafNodeCount();
     }
 
 };
 
 /**
- *
+ * @param {boolean} deep
  * @returns {BinaryNode}
  */
-BinaryNode.prototype.clone = function (deep) {
+BinaryNode.prototype.clone = function (deep = false) {
     const clone = new BinaryNode();
 
     clone.x0 = this.x0;

package/core/bvh2/aabb3/AABB3.js

@@ -6,7 +6,7 @@
 import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
 import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.js";
 import computeMortonCode from "../../geom/3d/morton/Morton.js";
-import { _boxSurfaceArea2, intersectRay, intersectSegment } from "./AABB3Math.js";
+import { boxSurfaceArea, intersectRay, intersectSegment } from "./AABB3Math.js";
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
 import { assert } from "../../assert.js";
 
@@ -81,7 +81,7 @@ AABB3.prototype.computeMortonCode = function () {
  * @returns {number}
  */
 AABB3.prototype.computeSurfaceArea = function () {
-    return _boxSurfaceArea2(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
+    return boxSurfaceArea(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
 };
 
 /**
@@ -296,7 +296,8 @@ AABB3.prototype.costForInclusion = function (other) {
 };
 
 /**
- *
+ * Surface area delta when including a given AABB
+ * 0 means that including a given AABB would not cause any change to total surface area
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0

package/core/bvh2/aabb3/AABB3Math.js

@@ -540,7 +540,7 @@ function boxSurfaceArea(x0, y0, z0, x1, y1, z1) {
     const dx = x1 - x0;
     const dy = y1 - y0;
     const dz = z1 - z0;
-    return (dx * dy + dy * dz + dz * dx) * 2; //2 of each side
+    return (dy * (dx + dz) + dz * dx) * 2; //2 of each side
 }
 
 /**

package/core/collection/list/List.js

@@ -719,40 +719,6 @@ List.prototype.copy = function (other) {
     }
 };
 
-/**
- *
- * @param {List} other
- * @param {function} elementComparator
- * @returns {number} -1, 0 or 1
- */
-List.prototype.compare = function (other, elementComparator) {
-    const thisLength = this.length;
-    const otherLength = other.length;
-
-    const deltaLength = thisLength - otherLength;
-
-    if (deltaLength !== 0) {
-        return deltaLength;
-    }
-
-    for (let i = 0; i < thisLength; i++) {
-        const thisElement = this.get(i);
-        const otherElement = other.get(i);
-
-        if (thisElement === otherElement) {
-            continue;
-        }
-
-        const elementDelta = elementComparator(thisElement, otherElement);
-
-        if (elementDelta !== 0) {
-            return elementDelta;
-        }
-    }
-
-    return 0;
-};
-
 /**
  * NOTE: do not modify resulting array
  * @returns {T[]}

package/core/collection/table/DataTypeByteSizes.js

@@ -19,3 +19,19 @@ export const DataTypeByteSizes = {
     [DataType.Float32]: 4,
     [DataType.Float64]: 8
 };
+
+
+/**
+ *
+ * @param {DataType} type
+ * @return {number}
+ */
+export function dataTypeByteSize(type) {
+    const size = DataTypeByteSizes[type];
+
+    if (size === undefined) {
+        throw new Error(`Unsupported type '${type}'`);
+    }
+
+    return size;
+}

package/engine/Engine.js

@@ -131,6 +131,11 @@ class Engine {
             const v_fps = (1 / stats.mean).toFixed(2);
 
 
+            // clear stats
+            m_render.clear();
+            m_sim.clear();
+            m_frame.clear();
+
             return `FPS: ${v_fps}, RENDER: ${v_render}ms, SIMULATION: ${v_sim}ms`;
         });
 

package/engine/development/performance/AbstractMetric.js

@@ -21,4 +21,8 @@ export class AbstractMetric {
     computeStats(result) {
         throw new Error('Not implemented');
     }
+
+    clear(){
+        throw new Error('Not implemented');
+    }
 }

package/engine/development/performance/RingBufferMetric.js

@@ -31,4 +31,8 @@ export class RingBufferMetric extends AbstractMetric {
         result.max = computeArrayMax(array, 0, data_count);
         result.min = computeArrayMin(array, 0, data_count);
     }
+
+    clear() {
+        this.__data.clear();
+    }
 }

package/engine/ecs/transform/Transform.js

@@ -162,7 +162,7 @@ export class Transform {
 
     /**
      *
-     * @param {Matrix4} matrix
+     * @param {THREE.Matrix4} matrix
      */
     fromThreeMatrix4(matrix) {
         this.fromMatrix4(matrix.elements);

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -125,16 +125,29 @@ export class ShadedGeometry {
     }
 
     __build_object() {
+        /**
+         * @type {THREE.Object3D}
+         */
+        let object;
+
         const mode = this.mode;
+        const shader = this.material;
+        const geo = this.geometry;
+
         if (mode === DrawMode.Triangles) {
-            this.__cached_object = new Mesh(this.geometry, this.material);
+            object = new Mesh(geo, shader);
         } else if (mode === DrawMode.Lines) {
-            this.__cached_object = new Line(this.geometry, this.material);
+            object = new Line(geo, shader);
         } else if (mode === DrawMode.LineSegments) {
-            this.__cached_object = new LineSegments(this.geometry, this.material);
+            object = new LineSegments(geo, shader);
         } else {
             throw new Error(`Unsupported draw mode '${mode}'`);
         }
+
+        object.matrixAutoUpdate = false;
+        object.frustumCulled = false;
+
+        this.__cached_object = object;
     }
 
     get bvh() {

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -81,6 +81,9 @@ export class ShadedGeometrySystem extends System {
 
         const leaf_node = sg.bvh;
 
+        // record entity on the BVH leaf
+        leaf_node.entity = entity;
+
         // remember entity for lookups
         sg.__entity = entity;
 

package/engine/graphics/ecs/mesh-v2/sample/load_gltf.js

@@ -0,0 +1,54 @@
+import { EngineHarness } from "../../../../EngineHarness.js";
+import { ShadedGeometrySystem } from "../ShadedGeometrySystem.js";
+import { GameAssetType } from "../../../../asset/GameAssetType.js";
+import { EngineConfiguration } from "../../../../EngineConfiguration.js";
+import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
+import { three_object_to_entity_composition } from "../three_object_to_entity_composition.js";
+import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {EngineHarness} harness
+ * @return {Promise<void>}
+ */
+async function init(harness) {
+    const engine = harness.engine;
+
+    const config = new EngineConfiguration();
+
+    config.addSystem(new ShadedGeometrySystem(engine));
+    config.addSystem(new AttachmentSystem());
+    config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
+
+    await config.apply(engine);
+
+    eh.initialize().then(main);
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    const em = engine.entityManager;
+
+    EngineHarness.buildBasics({
+        engine,
+        enableWater: false
+    })
+
+    const ecd = em.dataset;
+
+    const asset = await engine.assetManager.promise('moicon/06_04_hapro/08-clickable-assets-new/model.gltf', GameAssetType.ModelGLTF_JSON);
+
+    const three_object = asset.create();
+
+    const composition = three_object_to_entity_composition(three_object);
+
+    composition.build(ecd);
+}
+
+init(eh);

package/engine/graphics/ecs/mesh-v2/{prototypeShadedGeometry.js → sample/prototypeShadedGeometry.js}

@@ -1,8 +1,8 @@
-import { EngineHarness } from "../../../EngineHarness.js";
-import { ShadedGeometrySystem } from "./ShadedGeometrySystem.js";
-import EntityBuilder from "../../../ecs/EntityBuilder.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
-import { ShadedGeometry } from "./ShadedGeometry.js";
+import { EngineHarness } from "../../../../EngineHarness.js";
+import { ShadedGeometrySystem } from "../ShadedGeometrySystem.d.ts";
+import EntityBuilder from "../../../../ecs/EntityBuilder.d.ts";
+import { Transform } from "../../../../ecs/transform/Transform.d.ts";
+import { ShadedGeometry } from "../ShadedGeometry.d.ts";
 import { BoxBufferGeometry, MeshBasicMaterial } from "three";
 
 const eh = new EngineHarness();

package/engine/graphics/ecs/mesh-v2/three_object_to_entity_composition.js

@@ -0,0 +1,37 @@
+import { EntityNode } from "../../../ecs/parent/EntityNode.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "./ShadedGeometry.js";
+
+/**
+ *
+ * @param {THREE.Object3D} root
+ * @returns {EntityNode}
+ */
+export function three_object_to_entity_composition(root) {
+    const node = new EntityNode();
+
+    node.transform.fromMatrix4(root.matrix.elements);
+
+    node.entity.add(new Transform());
+
+    if (root.isMesh) {
+        if (root.isSkinnedMesh) {
+            throw new Error(`Skinned meshes are not supported`);
+        }
+
+        node.entity.add(ShadedGeometry.from(root.geometry, root.material));
+    }
+
+    const children = root.children;
+    const child_count = children.length;
+    for (let i = 0; i < child_count; i++) {
+        const child = children[i];
+
+        const child_node = three_object_to_entity_composition(child);
+
+
+        node.addChild(child_node);
+    }
+
+    return node;
+}

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

@@ -51,6 +51,17 @@ function custom_attribute_format_uv(spec, source) {
     spec.type = DataType.Float16;
 }
 
+/**
+ *
+ * @param {AttributeSpec} spec
+ * @param {THREE.BufferAttribute} source
+ */
+function custom_attribute_format_color(spec, source) {
+    // crush color data to 8 bit
+    spec.type = DataType.Uint8;
+    spec.normalized = true;
+}
+
 /**
  *
  * @param {AttributeSpec} spec
@@ -70,7 +81,11 @@ function format_attribute(spec, source, name) {
         case 'normal':
             custom_attribute_format_normal(spec, source);
             break;
+        case 'color':
+            custom_attribute_format_color(spec, source);
+            break;
         default:
+            spec.normalized = source.normalized;
             spec.type = typedArrayToDataType(source.array)
     }
 

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

@@ -14,6 +14,8 @@ export function compute_micron_buffer_array_constructor(type) {
             return Uint16Array;
         case DataType.Uint16:
             return Uint16Array;
+        case DataType.Uint8:
+            return Uint8Array;
         case DataType.Int8:
             return Int8Array;
         default:

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

@@ -9,6 +9,9 @@ import { DataType } from "../../../../core/collection/table/DataType.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint16.js";
 import { compute_micron_buffer_array_constructor } from "./compute_micron_buffer_array_constructor.js";
+import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
+import { dataTypeByteSize } from "../../../../core/collection/table/DataTypeByteSizes.js";
+import { clamp } from "../../../../core/math/clamp.js";
 
 function UintArrayForCount(count) {
 
@@ -90,6 +93,17 @@ function copy_attribute_data(vertex_count, index_map_backward, itemSize, attribu
     }
 }
 
+/**
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+function resample_normalized_uint16_to_uint8(value) {
+    const normalized = clamp(value / 65535, 0, 1);
+
+    return Math.round(normalized * 255);
+}
+
 /**
  *
  * @param {number} value
@@ -105,7 +119,8 @@ function normalize_to_int8(value) {
 const DataConverterType = {
     None: passThrough,
     Number2HalfFloat: to_half_float_uint16,
-    Normalize2Int8: normalize_to_int8
+    Normalize2Int8: normalize_to_int8,
+    ResampleNormalized_Uint16_to_Uint8: resample_normalized_uint16_to_uint8
 };
 
 /**
@@ -115,17 +130,36 @@ const DataConverterType = {
  * @returns {DataConverterType}
  */
 function compute_attribute_data_converter(source, spec) {
-    if (spec.type === DataType.Float16) {
+    const target_type = spec.type;
+    if (target_type === DataType.Float16) {
         return DataConverterType.Number2HalfFloat;
     } else if (spec.normalized && !source.normalized) {
         // source data can be normalized but isn't
-        if (spec.type === DataType.Int8) {
+        if (target_type === DataType.Int8) {
             return DataConverterType.Normalize2Int8;
         } else {
-            throw new Error(`Unsupported normalized type '${spec.type}'`);
+            throw new Error(`Unsupported normalized type '${target_type}'`);
         }
     } else {
-        return DataConverterType.None;
+        const source_array = source.array;
+
+        const source_type = typedArrayToDataType(source_array);
+
+        const target_byte_size = dataTypeByteSize(target_type);
+        const source_byte_size = dataTypeByteSize(source_type)
+
+        if (target_byte_size !== source_byte_size) {
+            // wrong data size
+
+            if (target_type === DataType.Uint8 && source_type === DataType.Uint16) {
+                return DataConverterType.ResampleNormalized_Uint16_to_Uint8;
+            } else {
+                throw new Error(`Unsupported conversion ${source_type} -> ${target_type}`);
+            }
+
+        } else {
+            return DataConverterType.None;
+        }
     }
 }
 

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

@@ -3,6 +3,7 @@ import { assert } from "../../../../core/assert.js";
 import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
+import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
 
 let id_counter = 0;
 
@@ -105,25 +106,18 @@ export class MicronGeometry {
 
             const patch = stack[stack_cursor];
 
-            // using group bounds because it's conservative, as we want to be able to hit LOD_0
-
-            // sphere test
-
-
             if (patch.lod === 0) {
                 // LOD 0 - source geometry
 
                 // cast against bounds
 
                 // sphere test
-
-                // TODO check what's wrong with sphere tests and re-enable them
-                // if (!sphere_array_intersects_ray(patch.bounding_sphere,
-                //     origin_x, origin_y, origin_z,
-                //     direction_x, direction_y, direction_z
-                // )) {
-                //     continue;
-                // }
+                if (!sphere_array_intersects_ray(patch.bounding_sphere,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z
+                )) {
+                    continue;
+                }
 
                 // box test
                 if (!aabb3_array_intersects_ray(
@@ -183,13 +177,15 @@ export class MicronGeometry {
 
             } else {
 
-                // TODO check what's wrong with sphere tests and re-enable them
-                // if (!sphere_array_intersects_ray(patch.group_bounding_sphere,
-                //     origin_x, origin_y, origin_z,
-                //     direction_x, direction_y, direction_z
-                // )) {
-                //     continue;
-                // }
+                // using group bounds because it's conservative, as we want to be able to hit LOD_0
+
+                // sphere test
+                if (!sphere_array_intersects_ray(patch.group_bounding_sphere,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z
+                )) {
+                    continue;
+                }
 
 
                 // box test (more expensive, different volume)

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -455,7 +455,7 @@ function init() {
     }
 
     // sample_gltf_sponza();
-    gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
+    // gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
     // sample_lucy();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
@@ -468,6 +468,12 @@ function init() {
     // gltf_sample('moicon/29_Dec_2021_Nammo/1/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/1-onematerial/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/2/model.gltf');
+    // gltf_sample('moicon/03_Jan_22_Demo/1-ground_floor/model.gltf');
+    // gltf_sample('moicon/03_Jan_22_Demo/2-1st_floor/model.gltf');
+    // gltf_sample('moicon/03_Jan_22_Demo/3-area_ground_floor/model.gltf');
+    // gltf_sample('moicon/03_Jan_22_Demo/4-area_1st_floor/model.gltf');
+    // gltf_sample('moicon/03_Jan_22_Demo/8-assets/model.gltf');
+    gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

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

@@ -24,6 +24,9 @@ function normalized_internal_format(dt, channel_count) {
         case DataType.Int8:
             suffix = '8_SNORM';
             break;
+        case DataType.Uint16:
+            suffix = '16UI';
+            break;
         default:
             throw new Error(`Unsupported data type '${dt}'`);
     }

package/engine/graphics/micron/render/instanced/shader/shader_rewrite_standard.js

@@ -160,6 +160,29 @@ export function shader_rewrite_standard(shader, uniforms, spec, column_count) {
 
     if (attribute_spec_color !== undefined) {
         // using color
+        const vx_color_value = `texelFetch(${gen_micron_vertex_attribute_texture_name('color')}, micron_vertex_uv, 0)`
+
+        rewrittenVertexShader = rewrittenVertexShader.replace(
+            '#include <color_vertex>',
+            `
+                #if defined( USE_COLOR_ALPHA )
+                    vColor = vec4( 1.0 );
+                #elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
+                    vColor = vec3( 1.0 );
+                #endif
+                
+                #ifdef USE_COLOR
+                
+                    #ifdef USE_COLOR_ALPHA
+                        vColor *= ${vx_color_value}.rgba;
+                    #else
+                        vColor *= ${vx_color_value}.rgb;
+                    #endif
+                    
+                #endif
+                
+                `
+        );
 
     }
 

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