@woosh/meep-engine 2.34.28 → 2.34.32

package/core/bvh2/aabb3/aabb3_array_contains_point.js

@@ -0,0 +1,18 @@
+//
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]} aabb
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {boolean}
+ */
+export function aabb3_array_contains_point(aabb, x, y, z) {
+    return x >= aabb[0]
+        && x <= aabb[3]
+        && y >= aabb[1]
+        && y <= aabb[4]
+        && z >= aabb[2]
+        && z <= aabb[5];
+}

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/core/geom/3d/sphere/sphere_array_intersects_point.js

@@ -0,0 +1,15 @@
+import { sphereIntersectsPoint } from "./sphereIntersectsPoint.js";
+
+//
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]} sphere
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {boolean}
+ */
+export function sphere_array_intersects_point(sphere, x, y, z) {
+    return sphereIntersectsPoint(sphere[0], sphere[1], sphere[2], sphere[3], x, y, z);
+}

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/sample/load_gltf.js

@@ -0,0 +1,52 @@
+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";
+
+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.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();
+
+    const transform = new Transform();
+    transform.fromMatrix4(root.matrix.elements);
+
+    node.entity.add(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/PatchRepresentation.js

@@ -31,6 +31,10 @@ export class PatchRepresentation {
             Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY
         );
 
+        /**
+         *
+         * @type {AABB3}
+         */
         this.group_aabb = new AABB3(0, 0, 0, 0, 0, 0);
 
         /**

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)
     }
 
@@ -202,6 +217,11 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
 
     const t_build_hierarchy_start = current_time_millis();
+
+    /**
+     *
+     * @type {PatchRepresentation}
+     */
     const root = await buildAbstractPatchHierarchy(patches);
 
     if (PRINT_VERBOSE_STATS) {

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
 };
 
 /**
@@ -125,7 +140,25 @@ function compute_attribute_data_converter(source, spec) {
             throw new Error(`Unsupported normalized type '${spec.type}'`);
         }
     } else {
-        return DataConverterType.None;
+        const source_array = source.array;
+
+        const source_type = typedArrayToDataType(source_array);
+
+        const target_byte_size = dataTypeByteSize(spec.type);
+        const source_byte_size = dataTypeByteSize(source_type)
+
+        if (target_byte_size !== source_byte_size) {
+            // wrong data size
+
+            if (spec.type === DataType.Uint8 && source_type === DataType.Uint16) {
+                return DataConverterType.ResampleNormalized_Uint16_to_Uint8;
+            } else {
+                throw new Error(`Unsupported conversion ${source_type} -> `);
+            }
+
+        } else {
+            return DataConverterType.None;
+        }
     }
 }
 

package/engine/graphics/micron/build/hierarchy/buildAbstractPatchHierarchy.js

@@ -48,13 +48,15 @@ async function assemble_graph(nodes) {
      */
     let __nodes = nodes.slice();
 
+    const initial_node_count = __nodes.length;
+
     /**
      *
      * @type {{value: number}}
      * @private
      */
     const __node_count = {
-        value: __nodes.length
+        value: initial_node_count
     };
 
     let level = 0;
@@ -136,6 +138,13 @@ async function assemble_graph(nodes) {
     // return root
     const root = __nodes[0];
 
+    if (initial_node_count === 1) {
+        // there are no children, whole hierarchy is just one node, set group bounds to equal node bounds
+        root.group_bounding_sphere.set(root.bounding_sphere);
+        root.group_aabb.copy(root.bounding_box);
+    }
+
+
     return root;
 }
 

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

@@ -1,6 +1,7 @@
 import {BufferGeometry} from "three";
 import {VertexDataSpec} from "../../geometry/VertexDataSpec";
 import {SurfacePoint3} from "../../../../core/geom/3d/SurfacePoint3";
+import {MicronGeometryPatch} from "./MicronGeometryPatch";
 
 export class MicronGeometry {
     vertex_spec: VertexDataSpec
@@ -14,4 +15,6 @@ export class MicronGeometry {
     ): SurfacePoint3[]
 
     readonly isMicronGeometry: boolean
+
+    readonly patches: MicronGeometryPatch[]
 }

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,43 +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
-
-            // 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;
-            // }
-
-
-            // box test (more expensive, different volume)
-            if (!aabb3_array_intersects_ray(
-                patch.group_bounding_box,
-                origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z
-            )) {
-                // no intersection
-                continue;
-            }
-
             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(
@@ -200,6 +176,28 @@ export class MicronGeometry {
                 }
 
             } else {
+
+                // 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)
+                if (!aabb3_array_intersects_ray(
+                    patch.group_bounding_box,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z
+                )) {
+                    // no intersection
+                    continue;
+                }
+
                 // refine more
                 const children = patch.children;
 

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

@@ -0,0 +1,3 @@
+export class MicronGeometryPatch {
+
+}

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.spec.js

@@ -0,0 +1,63 @@
+import { MicronGeometryPatch } from "../MicronGeometryPatch.js";
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../MicronGeometry.js";
+import { VertexDataSpec } from "../../../geometry/VertexDataSpec.js";
+import { AttributeSpec } from "../../../geometry/AttributeSpec.js";
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+import { MicronGeometryBinarySerializationAdapter } from "./MicronGeometryBinarySerializationAdapter.js";
+
+function sampleGeometry() {
+    const a = new MicronGeometryPatch();
+
+    a.vertex_attribute_arrays[0] = new Uint8Array([
+        7, 11, 13,
+        17, 23, 29,
+        31, 39, 43
+    ]);
+    a.vertex_count = 3;
+
+    a.face_indices = new Uint8Array([1, 2, 3]);
+    a.polygon_count = 1;
+
+    a.group_error = 1.234;
+
+    a.bounding_box.set([7, 11, 13, 31, 39, 43]);
+    a.group_bounding_box.set([7, 11, 13, 31, 39, 43]);
+    a.bounding_sphere.set([19, 25, 28, 50.1]);
+    a.group_bounding_sphere.set([19, 25, 28, 50.1]);
+
+    const g_a = new MicronGeometry();
+
+    const vertex_spec = new VertexDataSpec();
+    vertex_spec.add(AttributeSpec.fromJSON({
+        name: 'position',
+        type: DataType.Uint8,
+        itemSize: 3,
+        normalized: false
+    }));
+
+    g_a.vertex_spec = vertex_spec;
+    g_a.root = a;
+    g_a.initialize();
+
+    return g_a;
+}
+
+test("serialization/deserialization consistency", () => {
+    const g_a = sampleGeometry();
+
+    const buffer = new BinaryBuffer();
+
+    const adapter = new MicronGeometryBinarySerializationAdapter();
+
+    adapter.serialize(buffer, g_a);
+
+
+    const g_b = new MicronGeometry();
+
+    buffer.position = 0;
+    adapter.deserialize(buffer, g_b);
+
+    expect(g_b.vertex_spec.equals(g_a.vertex_spec)).toBe(true);
+    expect(g_b.patches.length).toEqual(g_a.patches.length);
+});

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

@@ -0,0 +1,69 @@
+import { noop } from "../../../../core/function/Functions.js";
+import { aabb3_array_contains_point } from "../../../../core/bvh2/aabb3/aabb3_array_contains_point.js";
+import { sphere_array_intersects_point } from "../../../../core/geom/3d/sphere/sphere_array_intersects_point.js";
+
+/**
+ *
+ * @param {MicronGeometryPatch} patch
+ * @param {VertexDataSpec} vertex_spec
+ * @param {function(string)} [error_consumer]
+ * @returns {boolean}
+ */
+export function validate_patch_bounds(patch, vertex_spec, error_consumer = noop) {
+    const position_attribute_index = vertex_spec.getAttributeIndexByName('position');
+
+    if (position_attribute_index === -1) {
+        error_consumer(`No 'position' attribute found`);
+        // technically any bounds are valid if there is no position
+        return true;
+    }
+
+    const position_data = patch.vertex_attribute_arrays[position_attribute_index];
+
+    let b_sphere_valid = true;
+    let b_box_valid = true;
+    let gb_sphere_valid = true;
+    let gb_box_valid = true;
+
+    for (let i = 0; i < this.vertex_count; i++) {
+        const i3 = i * 3;
+
+        const x = position_data[i3];
+        const y = position_data[i3 + 1];
+        const z = position_data[i3 + 2];
+
+        if (!aabb3_array_contains_point(patch.bounding_box, x, y, z)) {
+            b_box_valid = false;
+        }
+
+        if (!aabb3_array_contains_point(patch.group_bounding_box, x, y, z)) {
+            gb_box_valid = false;
+        }
+
+        if (!sphere_array_intersects_point(patch.bounding_sphere, x, y, z)) {
+            b_sphere_valid = false;
+        }
+
+        if (!sphere_array_intersects_point(patch.group_bounding_sphere, x, y, z)) {
+            gb_sphere_valid = false;
+        }
+    }
+
+    if (!b_sphere_valid) {
+        error_consumer('.bounding_sphere is violated');
+    }
+
+    if (!gb_sphere_valid) {
+        error_consumer('.group_bounding_sphere is violated');
+    }
+
+    if (!b_box_valid) {
+        error_consumer('.bounding_box is violated');
+    }
+
+    if (!gb_box_valid) {
+        error_consumer('.group_bounding_box is violated');
+    }
+
+    return b_sphere_valid && gb_sphere_valid && b_box_valid && gb_box_valid;
+}

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