@woosh/meep-engine 2.35.10 → 2.35.12

package/core/binary/BinaryBuffer.js

@@ -3,6 +3,7 @@
  * @enum {boolean}
  */
 import { assert } from "../assert.js";
+import { array_copy } from "../collection/array/copyArray.js";
 
 /**
  *
@@ -30,17 +31,50 @@ function BinaryBuffer() {
      */
     this.endianness = EndianType.BigEndian;
 
+    /**
+     *
+     * @type {number}
+     */
     this.position = 0;
+
+    /**
+     *
+     * @type {number}
+     */
     this.length = 0;
+
+    /**
+     *
+     * @type {number}
+     */
     this.capacity = 0;
 
     /**
      *
      * @type {ArrayBuffer}
+     * @private
      */
     this.data = new ArrayBuffer(0);
+
+    /**
+     *
+     * @type {DataView}
+     * @private
+     */
     this.dataView = new DataView(this.data);
 
+    /**
+     *
+     * @type {Uint8Array}
+     * @private
+     */
+    this.__data_uint8 = new Uint8Array(0);
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
     this.__growFactor = 1.1;
 }
 
@@ -50,6 +84,7 @@ function BinaryBuffer() {
 BinaryBuffer.prototype.fromArrayBuffer = function (arrayBuffer) {
     this.data = arrayBuffer;
     this.dataView = new DataView(arrayBuffer);
+    this.__data_uint8 = new Uint8Array(arrayBuffer);
 
     this.capacity = arrayBuffer.byteLength;
     //assume that all the data is useful
@@ -85,7 +120,7 @@ BinaryBuffer.prototype.trim = function () {
  * @param {number} capacity
  */
 BinaryBuffer.prototype.setCapacity = function (capacity) {
-    const oldData = new Uint8Array(this.data);
+    const oldData = this.__data_uint8;
     const newData = new Uint8Array(capacity);
 
     //copy old data
@@ -93,7 +128,7 @@ BinaryBuffer.prototype.setCapacity = function (capacity) {
     newData.set(oldData.subarray(0, copyLength), 0);
 
     this.data = newData.buffer;
-
+    this.__data_uint8 = newData;
     this.dataView = new DataView(this.data);
 
     this.capacity = capacity;
@@ -680,11 +715,11 @@ BinaryBuffer.prototype.writeUint32LE = function (value) {
 /**
  *
  * @param {Uint8Array|Uint8ClampedArray} array
- * @param {number} sourceOffset
+ * @param {number} source_offset
  * @param {number} length
  */
-BinaryBuffer.prototype.writeBytes = function (array, sourceOffset, length) {
-    const source_end = sourceOffset + length;
+BinaryBuffer.prototype.writeBytes = function (array, source_offset, length) {
+    const source_end = source_offset + length;
     assert.greaterThanOrEqual(array.length, source_end, 'source array underflow');
 
     const targetAddress = this.position;
@@ -693,18 +728,21 @@ BinaryBuffer.prototype.writeBytes = function (array, sourceOffset, length) {
 
     this.ensureCapacity(end);
 
-    const destination = new Uint8Array(this.data, targetAddress, length);
+    if (source_offset === 0 && array.length === length) {
+        // copying entire source array
 
-    if (typeof array.subarray === "function") {
+        this.__data_uint8.set(array, targetAddress);
+
+    } else if (typeof array.subarray === "function") {
         // typed array, use "subarray" method
 
-        destination.set(array.subarray(sourceOffset, source_end));
+        this.__data_uint8.set(array.subarray(source_offset, source_end), targetAddress);
 
     } else {
         // not a typed array, copy byte by byte manually
 
         for (let i = 0; i < length; i++) {
-            destination[i] = array[sourceOffset + i];
+            this.__data_uint8[targetAddress + i] = array[source_offset + i];
         }
 
     }
@@ -714,14 +752,23 @@ BinaryBuffer.prototype.writeBytes = function (array, sourceOffset, length) {
 
 /**
  *
- * @param {Uint8Array} target
- * @param {number} targetOffset
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset
  * @param {number} length
  */
-BinaryBuffer.prototype.readBytes = function (target, targetOffset, length) {
-    const end = this.position + length;
-    const uint8Array = new Uint8Array(this.data);
-    target.set(uint8Array.subarray(this.position, end), targetOffset);
+BinaryBuffer.prototype.readBytes = function (destination, destination_offset, length) {
+    const source_position = this.position;
+
+    const end = source_position + length;
+
+    const uint8 = this.__data_uint8;
+
+    if (length < 128) {
+        // small copy
+        array_copy(uint8, source_position, destination, destination_offset, length);
+    } else {
+        destination.set(uint8.subarray(source_position, end), destination_offset);
+    }
 
     this.position = end;
 };
@@ -764,7 +811,7 @@ BinaryBuffer.prototype.writeUTF8String = function (string) {
 
     this.ensureCapacity(tlen + at);
 
-    let target = new Uint8Array(this.data);  // ... but at 8 byte offset
+    let target = this.__data_uint8;  // ... but at 8 byte offset
 
 
     while (pos < len) {
@@ -791,7 +838,7 @@ BinaryBuffer.prototype.writeUTF8String = function (string) {
 
             this.ensureCapacity(tlen + startPosition);
 
-            target = new Uint8Array(this.data);
+            target = this.__data_uint8;
         }
 
         if ((value & 0xffffff80) === 0) {  // 1-byte
@@ -851,7 +898,7 @@ BinaryBuffer.prototype.readUTF8String = function () {
         return undefined;
     }
 
-    const bytes = new Uint8Array(this.data);
+    const bytes = this.__data_uint8;
 
 
     let result = "";

package/engine/graphics/ecs/camera/Camera.js

@@ -62,7 +62,7 @@ export class Camera {
          * @type {number}
          * @private
          */
-        this.__clip_far = 0;
+        this.__clip_far = 100;
 
         /**
          * Far clipping plane

package/engine/graphics/ecs/camera/CameraSystem.js

@@ -297,7 +297,7 @@ export class CameraSystem extends System {
              * @param {Camera} c
              */
             function visitCameraEntity(c) {
-                if (c.object !== null) {
+                if (c.object === null) {
                     return;
                 }
 
@@ -305,7 +305,7 @@ export class CameraSystem extends System {
                     return;
                 }
 
-                if (c.autoClip) {
+                if (c.autoClip === true) {
                     autoSetClippingPlanes(c, layers);
                 } else {
                     c.object.far = c.clip_far;

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

@@ -313,13 +313,19 @@ export class ShadedGeometrySystem extends System {
                 const local_direction_x = scratch_m4[0] * direction_x + scratch_m4[4] * direction_y + scratch_m4[8] * direction_z;
                 const local_direction_y = scratch_m4[1] * direction_x + scratch_m4[5] * direction_y + scratch_m4[9] * direction_z;
                 const local_direction_z = scratch_m4[2] * direction_x + scratch_m4[6] * direction_y + scratch_m4[10] * direction_z;
-                // NOTE: direction is not normalized
+
+                const local_direction_magnitude = Math.hypot(local_direction_x, local_direction_y, local_direction_z);
+                const local_direction_magnitude_inverse = 1 / local_direction_magnitude;
+
+                const local_direction_normalized_x = local_direction_x * local_direction_magnitude_inverse;
+                const local_direction_normalized_y = local_direction_y * local_direction_magnitude_inverse;
+                const local_direction_normalized_z = local_direction_z * local_direction_magnitude_inverse;
 
                 const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_primitive(
                     scratch_point,
                     sg.geometry,
                     local_origin_x, local_origin_y, local_origin_z,
-                    local_direction_x, local_direction_y, local_direction_z
+                    local_direction_normalized_x, local_direction_normalized_y, local_direction_normalized_z
                 );
 
                 if (!geometry_hit_found) {

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

@@ -20,6 +20,9 @@ import { randomFromArray } from "../../../../../core/math/random/randomFromArray
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { MicronShadedGeometryRenderAdapter } from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";
+import { MicronRenderContext } from "../../../micron/render/v1/MicronRenderContext.js";
+import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
 
 const eh = new EngineHarness();
 
@@ -50,7 +53,17 @@ async function main(engine) {
 
     const em = engine.entityManager;
 
-    await em.addSystem(new ShadedGeometrySystem(engine));
+    const sgs = new ShadedGeometrySystem(engine);
+
+    const mrc = new MicronRenderContext();
+    sgs.register_render_adapter(2, () => {
+        const adapter = new MicronShadedGeometryRenderAdapter();
+        adapter.ctx = mrc;
+
+        return adapter;
+    });
+
+    await em.addSystem(sgs);
     await em.addSystem(new BehaviorSystem(engine));
 
     EngineHarness.buildBasics({
@@ -74,7 +87,7 @@ async function main(engine) {
 
     const random = seededRandom(0);
 
-    const INSTANCE_COUNT = 0;
+    const INSTANCE_COUNT = 10000;
 
     const geometries = [];
 
@@ -87,7 +100,9 @@ async function main(engine) {
         const sg = ShadedGeometry.from(geometry, material);
 
         // sg.draw_method = DRAW_METHOD_PLAIN;
-        sg.draw_method = DRAW_METHOD_INSTANCED;
+        // sg.draw_method = DRAW_METHOD_INSTANCED;
+        // sg.draw_method = 2;
+        sg.draw_method = randomIntegerBetween(random, 0, 2);
         // sg.draw_method = random() > 0.01 ? DRAW_METHOD_INSTANCED : DRAW_METHOD_PLAIN;
         sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
 
@@ -105,7 +120,7 @@ async function main(engine) {
             .build(ecd);
     }
 
-    makeMovingShadedGeometry().build(ecd);
+    // makeMovingShadedGeometry().build(ecd);
 
     debug_button(engine, () => {
         const dot = convert_bvh_to_dot_format_string(engine.graphics.layers.getLayerByName('shaded-geometry').bvh);

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

@@ -121,7 +121,7 @@ const PRINT_VERBOSE_STATS = false;
 /**
  *
  * @param {THREE.BufferGeometry} input
- * @returns {MicronGeometry}
+ * @returns {Promise<MicronGeometry>}
  */
 export async function buildMicronGeometryFromBufferGeometry(input) {
     const source_geometry = deinterleaveBufferGeometry(input);

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -1,5 +1,14 @@
 import { AbstractRenderAdapter } from "../../../ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
+import { buildMicronGeometryFromBufferGeometry } from "../../build/buildMicronGeometryFromBufferGeometry.js";
+import { ShadedGeometryFlags } from "../../../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { MaterialVertexSpec, MaterialVertexSpecFlags } from "../../render/v1/MaterialVertexSpec.js";
+
+/**
+ *
+ * @type {MaterialVertexSpec}
+ */
+const scratch_mvc = new MaterialVertexSpec();
 
 export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
@@ -21,19 +30,42 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
         /**
          *
-         * @type {Set<MaterialContext>}
+         * @type {Map<number, Promise>}
          * @private
          */
-        this.__active_contexts = new Set();
+        this.__geometry_building_promises = new Map();
     }
 
     add(sg) {
 
-        const micron_geometry = this.__geometry_map.get(sg.geometry.id);
+        const geometry_id = sg.geometry.id;
+
+        const micron_geometry = this.__geometry_map.get(geometry_id);
+
+        if (micron_geometry === undefined) {
+            // no micron geometry
+            if (!this.__geometry_building_promises.has(geometry_id)) {
+                const p = buildMicronGeometryFromBufferGeometry(sg.geometry);
+
+                this.__geometry_building_promises.set(geometry_id, p);
+
+                p.then(mg => this.__geometry_map.set(geometry_id, mg));
+            }
+            return;
+        }
 
         // populate virtual geometry for this instance
         this.ctx.builder.buildForMesh(sg.entity, micron_geometry, sg.transform);
 
+        scratch_mvc.material = sg.material;
+        scratch_mvc.spec = micron_geometry.vertex_spec;
+        scratch_mvc.writeFlag(MaterialVertexSpecFlags.CastShadow, sg.getFlag(ShadedGeometryFlags.CastShadow));
+        scratch_mvc.writeFlag(MaterialVertexSpecFlags.ReceiveShadow, sg.getFlag(ShadedGeometryFlags.ReceiveShadow));
+
+        const material_context = this.ctx.obtain_material(scratch_mvc);
+
+        material_context.instances.add(sg.entity);
+
     }
 
     /**
@@ -69,6 +101,16 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
     build_end() {
         this.ctx.render();
+
+        const material_contexts = this.ctx.contexts_array;
+        const contexts_count = material_contexts.length;
+        for (let i = 0; i < contexts_count; i++) {
+            const mc = material_contexts[i];
+
+            if (mc.instances.size > 0) {
+                this.__objects[this.__object_count++] = mc.mesh;
+            }
+        }
     }
 
     dispose() {

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

@@ -125,7 +125,7 @@ export class ThreeInstancedAdapter {
 
     /**
      *
-     * @param {Uint32Array[]} patches
+     * @param {Uint32Array} patches
      * @param {number} patch_count
      * @param {VirtualGeometry} virtual_geometry
      */

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

@@ -52,7 +52,7 @@ export class MaterialContext {
 
         /**
          *
-         * @type {MicronGeometryPatchOccurrence[]}
+         * @type {Uint32Array|number[]}
          */
         this.__patches = [];
 
@@ -63,16 +63,6 @@ export class MaterialContext {
         this.__patch_count = 0;
     }
 
-
-    /**
-     *
-     * @param {MicronGeometryPatchOccurrence} occurrence
-     * @returns {boolean}
-     */
-    filter(occurrence) {
-        return this.instances.has(occurrence.instance_id);
-    }
-
     init() {
 
         const material = this.material.clone();

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

@@ -1,3 +1,8 @@
+export const MaterialVertexSpecFlags = {
+    CastShadow: 1,
+    ReceiveShadow: 2
+};
+
 export class MaterialVertexSpec {
     constructor() {
         /**
@@ -10,6 +15,52 @@ export class MaterialVertexSpec {
          * @type {THREE.Material|null}
          */
         this.material = null;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.flags = 0;
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|MaterialVertexSpecFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
     }
 
     /**
@@ -19,6 +70,7 @@ export class MaterialVertexSpec {
     copy(other) {
         this.spec = other.spec;
         this.material = other.material;
+        this.flags = other.flags;
     }
 
     /**
@@ -47,7 +99,7 @@ export class MaterialVertexSpec {
     }
 
     hash() {
-        return this.spec.hash() ^ this.material.id;
+        return this.spec.hash() ^ this.material.id ^ this.flags;
     }
 
     equals(other) {
@@ -55,8 +107,9 @@ export class MaterialVertexSpec {
             return true;
         }
 
-        return this.spec.equals(other.spec)
+        return this.flags === other.flags
             && this.material === other.material
+            && this.spec.equals(other.spec)
             ;
     }
 }

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

@@ -3,7 +3,7 @@ import { VirtualGeometryBuilder } from "../VirtualGeometryBuilder.js";
 import { HashMap } from "../../../../../core/collection/HashMap.js";
 import Signal from "../../../../../core/events/signal/Signal.js";
 import { MaterialContext } from "./MaterialContext.js";
-import { MaterialVertexSpec } from "./MaterialVertexSpec.js";
+import { MaterialVertexSpec, MaterialVertexSpecFlags } from "./MaterialVertexSpec.js";
 
 /**
  *
@@ -39,6 +39,14 @@ export class MicronRenderContext {
         };
     }
 
+    /**
+     *
+     * @returns {MaterialContext[]}
+     */
+    get contexts_array() {
+        return this.__contexts_array;
+    }
+
     /**
      * Enable/disable wireframe rendering
      * @param {boolean} x
@@ -55,27 +63,27 @@ export class MicronRenderContext {
 
     /**
      *
-     * @param {VertexDataSpec} spec
-     * @param {Material} m
+     * @param {MaterialVertexSpec} descriptor
      * @returns {MaterialContext}
      */
-    obtain_material(spec, m) {
-        scratch_mvc.material = m;
-        scratch_mvc.spec = spec;
+    obtain_material(descriptor) {
 
-        const existing = this.material_contexts.get(scratch_mvc);
+        const existing = this.material_contexts.get(descriptor);
 
         if (existing !== undefined) {
             return existing;
         }
 
         // create a separate instance to be stored alongside the context
-        const key = scratch_mvc.clone();
+        const key = descriptor.clone();
 
-        const ctx = new MaterialContext(spec, m);
+        const ctx = new MaterialContext(descriptor.spec, descriptor.material);
 
         ctx.init();
 
+        ctx.mesh.castShadow = descriptor.getFlag(MaterialVertexSpecFlags.CastShadow);
+        ctx.mesh.receiveShadow = descriptor.getFlag(MaterialVertexSpecFlags.ReceiveShadow);
+
         this.material_contexts.set(key, ctx);
         this.__contexts_array.push(ctx);
 
@@ -95,7 +103,9 @@ export class MicronRenderContext {
          */
         const instance_to_ctx = new Map();
 
-        for (let i = 0; i < context_count; i++) {
+        let i = 0;
+
+        for (i = 0; i < context_count; i++) {
             const ctx = contexts[i];
             ctx.__patch_count = 0;
 
@@ -109,7 +119,7 @@ export class MicronRenderContext {
         const patch_count = geometry.patch_count;
         const patches = geometry.patches;
 
-        for (let i = 0; i < patch_count; i++) {
+        for (i = 0; i < patch_count; i++) {
             const i3 = i * 3;
 
             const instance_id = patches[i3];
@@ -118,7 +128,9 @@ export class MicronRenderContext {
 
             const ctx = instance_to_ctx.get(instance_id);
 
-            const target_address = ctx.__patch_count * 3;
+            const target_index = ctx.__patch_count;
+            const target_address = target_index * 3;
+
             ctx.__patch_count++;
 
             const ctx_patches = ctx.__patches;
@@ -129,7 +141,7 @@ export class MicronRenderContext {
         }
 
         // build each context
-        for (let i = 0; i < context_count; i++) {
+        for (i = 0; i < context_count; i++) {
             const ctx = contexts[i];
 
             ctx.build(geometry);

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

@@ -2,6 +2,13 @@ import Vector2 from "../../../../../core/geom/Vector2.js";
 import { MaterialContext } from "./MaterialContext.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 import { MicronRenderContext } from "./MicronRenderContext.js";
+import { MaterialVertexSpec, MaterialVertexSpecFlags } from "./MaterialVertexSpec.js";
+
+/**
+ *
+ * @type {MaterialVertexSpec}
+ */
+const scratch_mvc = new MaterialVertexSpec();
 
 export class VGThreeRenderer {
     constructor() {
@@ -73,7 +80,12 @@ export class VGThreeRenderer {
                  */
                 const m = o;
 
-                const ctx = render_context.obtain_material(m.geometry.vertex_spec, m.material);
+                scratch_mvc.material = m.material;
+                scratch_mvc.spec = m.geometry.vertex_spec;
+                scratch_mvc.writeFlag(MaterialVertexSpecFlags.CastShadow, m.castShadow);
+                scratch_mvc.writeFlag(MaterialVertexSpecFlags.ReceiveShadow, m.receiveShadow);
+
+                const ctx = render_context.obtain_material(scratch_mvc);
 
                 ctx.instances.add(o.instance_id);
             }

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