@woosh/meep-engine 2.35.8 → 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.d.ts

@@ -9,6 +9,9 @@ export class Camera {
 
     autoClip: boolean
 
+    clip_near: number
+    clip_far: number
+
     computeProjectionMatrix(result: Matrix4): boolean
 
     projectWorldPointOntoNearPlane(x: number, y: number, z: number, result: Vector3): void

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

@@ -26,7 +26,7 @@ export const ProjectionType = {
 export class Camera {
     constructor() {
         /**
-         *
+         * Whether clipping planes should be automatically calculated or not
          * @type {boolean}
          */
         this.autoClip = true;
@@ -56,6 +56,44 @@ export class Camera {
          * @type {ObservedBoolean}
          */
         this.active = new ObservedBoolean(false);
+
+        /**
+         * Near clipping plane
+         * @type {number}
+         * @private
+         */
+        this.__clip_far = 100;
+
+        /**
+         * Far clipping plane
+         * @type {number}
+         * @private
+         */
+        this.__clip_near = 0.1;
+    }
+
+    get clip_far() {
+        return this.__clip_far;
+    }
+
+    set clip_far(v) {
+        this.__clip_far = v;
+
+        if (this.object !== null) {
+            this.object.far = v;
+        }
+    }
+
+    get clip_near() {
+        return this.__clip_near;
+    }
+
+    set clip_near(v) {
+        this.__clip_near = v;
+
+        if (this.object !== null) {
+            this.object.near = v;
+        }
     }
 
     updateMatrices() {

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

@@ -9,7 +9,6 @@ import { Transform } from '../../../ecs/transform/Transform.js';
 import {
     Frustum as ThreeFrustum,
     Matrix4,
-    Matrix4 as ThreeMatrix4,
     OrthographicCamera as ThreeOrthographicCamera,
     PerspectiveCamera as ThreePerspectiveCamera,
     Vector3 as ThreeVector3,
@@ -76,16 +75,25 @@ function setAspectRatio(camera, width, height) {
  * @returns {PerspectiveCamera| OrthographicCamera}
  */
 function buildThreeCamera(component) {
+
+    let result;
     switch (component.projectionType.getValue()) {
         default:
             console.error(`Unsupported camera projection type "${component.projectionType.getValue()}", defaulting to perspective projection`);
         //fallthrough
         case Camera.ProjectionType.Perspective:
-            return new ThreePerspectiveCamera(component.fov.getValue(), 1, 1, 50);
-
+            result = new ThreePerspectiveCamera(component.fov.getValue(), 1, 1, 50);
+            break;
         case Camera.ProjectionType.Orthographic:
-            return new ThreeOrthographicCamera(-10, 10, 20, -20, 1, 1);
+            result = new ThreeOrthographicCamera(-10, 10, 20, -20, 1, 1);
+            break;
     }
+
+
+    result.far = component.clip_far;
+    result.near = component.clip_near;
+
+    return result;
 }
 
 export class CameraSystem extends System {
@@ -289,8 +297,19 @@ export class CameraSystem extends System {
              * @param {Camera} c
              */
             function visitCameraEntity(c) {
-                if (c.active.getValue() && c.autoClip && c.object !== null) {
+                if (c.object === null) {
+                    return;
+                }
+
+                if (!c.active.getValue()) {
+                    return;
+                }
+
+                if (c.autoClip === true) {
                     autoSetClippingPlanes(c, layers);
+                } else {
+                    c.object.far = c.clip_far;
+                    c.object.near = c.clip_near;
                 }
             }
 
@@ -376,7 +395,7 @@ export class CameraSystem extends System {
     }
 }
 
-const matrix4 = new ThreeMatrix4();
+const matrix4 = new Matrix4();
 
 /**
  *

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/ecs/path/PathDisplaySystem.js

@@ -10,7 +10,7 @@ import { RibbonXPlugin } from "../../trail/x/RibbonXPlugin.js";
 import { RibbonPathBuilder } from "./ribbon/RibbonPathBuilder.js";
 import { PathEvents } from "../../../navigation/ecs/components/PathEvents.js";
 import { assert } from "../../../../core/assert.js";
-import { TubePathBuilder } from "./tube/TubePathBuilder.js";
+import { TubePathBuilder } from "./tube/build/TubePathBuilder.js";
 
 const builders = {
     [PathDisplayType.None]: function (style, path, result) {

package/engine/graphics/ecs/path/testPathDisplaySystem.js

@@ -1,5 +1,4 @@
 import { EngineHarness } from "../../../EngineHarness.js";
-import RenderSystem from "../../../ecs/systems/RenderSystem.js";
 import { makeEngineOptionsModel } from "../../../../../model/game/options/makeEngineOptionsModel.js";
 import Path from "../../../navigation/ecs/components/Path.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
@@ -68,6 +67,7 @@ import { TubePathStyle } from "./tube/TubePathStyle.js";
 import { TubeMaterialType } from "./tube/TubeMaterialType.js";
 import { MatcapMaterialDefinition } from "./tube/MatcapMaterialDefinition.js";
 import { TextureAssetLoader } from "../../../asset/loaders/texture/TextureAssetLoader.js";
+import { ShadedGeometrySystem } from "../mesh-v2/ShadedGeometrySystem.js";
 
 const engineHarness = new EngineHarness();
 
@@ -156,7 +156,8 @@ function makeConfig(engine) {
 async function init(harness) {
     const engine = harness.engine;
 
-    engine.entityManager.addSystem(new RenderSystem(engine.graphics));
+    // engine.entityManager.addSystem(new RenderSystem(engine.graphics));
+    engine.entityManager.addSystem(new ShadedGeometrySystem(engine));
 
     makeEngineOptionsModel(engine.options, engine);
 
@@ -323,8 +324,8 @@ function main(engine) {
     EngineHarness.buildBasics({ engine });
 
     const _p = new Path();
-    // _p.interpolation = InterpolationType.CatmullRom;
-    _p.interpolation = InterpolationType.Linear;
+    _p.interpolation = InterpolationType.CatmullRom;
+    // _p.interpolation = InterpolationType.Linear;
 
     // _p.setPositionsFromVectorArray(Path.smoothPath([
     //     new Vector3(3, 1, 1),
@@ -352,14 +353,14 @@ function main(engine) {
 
     const pathDisplay = new PathDisplay();
     pathDisplay.specs.push(
-        // PathDisplaySpec.from(
-        //     PathDisplayType.Ribbon,
-        //     trailPathStyle
-        // ),
-        // PathDisplaySpec.from(
-        //     PathDisplayType.Entity,
-        //     sample_style_entity()
-        // ),
+        PathDisplaySpec.from(
+            PathDisplayType.Ribbon,
+            trailPathStyle
+        ),
+        PathDisplaySpec.from(
+            PathDisplayType.Entity,
+            sample_style_entity()
+        ),
         PathDisplaySpec.from(
             PathDisplayType.Tube,
             sample_style_tube()

package/engine/graphics/ecs/path/tube/TubePathStyle.d.ts

@@ -11,4 +11,6 @@ export class TubePathStyle {
     public width: number
     public resolution: number
     public radial_resolution: number
+    public cast_shadow: boolean
+    public receive_shadow: boolean
 }

package/engine/graphics/ecs/path/tube/TubePathStyle.js

@@ -5,8 +5,15 @@ import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
 
 export class TubePathStyle {
     constructor() {
+        /**
+         *
+         * @type {Color}
+         */
         this.color = new Color(1, 1, 1);
 
+        /**
+         * @type {TubeMaterialType}
+         */
         this.material_type = TubeMaterialType.Unknown;
 
         /**
@@ -15,13 +22,43 @@ export class TubePathStyle {
          */
         this.material = null;
 
+        /**
+         *
+         * @type {number}
+         */
         this.opacity = 1;
+
+        /**
+         *
+         * @type {number}
+         */
         this.width = 1;
 
         // TODO expose shading style "flat/smooth"
 
+        /**
+         *
+         * @type {number}
+         */
         this.resolution = 10;
+
+        /**
+         *
+         * @type {number}
+         */
         this.radial_resolution = 16;
+
+        /**
+         *
+         * @type {boolean}
+         */
+        this.cast_shadow = false;
+
+        /**
+         *
+         * @type {boolean}
+         */
+        this.receive_shadow = false;
     }
 
     static fromJSON(j) {
@@ -39,7 +76,9 @@ export class TubePathStyle {
                  opacity = 1,
                  width = 1,
                  resolution = 10,
-                 radial_resolution = 16
+                 radial_resolution = 16,
+                 cast_shadow = false,
+                 receive_shadow = false
              }) {
         assert.enum(material_type, TubeMaterialType, 'material_type');
 
@@ -55,6 +94,9 @@ export class TubePathStyle {
         this.resolution = resolution;
         this.radial_resolution = radial_resolution;
 
+        this.cast_shadow = cast_shadow;
+        this.receive_shadow = receive_shadow;
+
         switch (material_type) {
             case TubeMaterialType.Matcap:
                 this.material = new MatcapMaterialDefinition();

package/engine/graphics/ecs/path/tube/build/TubePathBuilder.js

@@ -0,0 +1,138 @@
+import { BufferGeometry, MeshMatcapMaterial, MeshStandardMaterial, Vector3 } from "three";
+import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
+import EntityBuilder from "../../../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../../../ecs/transform/Transform.js";
+import { TubeMaterialType } from "../TubeMaterialType.js";
+import { GameAssetType } from "../../../../../asset/GameAssetType.js";
+import { build_geometry_linear } from "./build_geometry_linear.js";
+import { build_geometry_catmullrom } from "./build_geometry_catmullrom.js";
+import { ShadedGeometry } from "../../../mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../../mesh-v2/ShadedGeometryFlags.js";
+
+export class TubePathBuilder {
+    constructor() {
+        /**
+         *
+         * @type {TubePathStyle|null}
+         */
+        this.style = null;
+
+        /**
+         *
+         * @type {Path|null}
+         */
+        this.path = null;
+
+        /**
+         *
+         * @type {MaterialManager|null}
+         */
+        this.materials = null;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         */
+        this.assetManager = null;
+    }
+
+    setPath(path) {
+        this.path = path;
+    }
+
+    setStyle(style) {
+        this.style = style;
+    }
+
+    setMaterials(m) {
+        this.materials = m;
+    }
+
+    setAssetManager(assetManager) {
+        this.assetManager = assetManager;
+    }
+
+    /**
+     *
+     * @param {EntityBuilder[]} destination
+     */
+    build(destination) {
+        const style = this.style;
+
+        // generate three.js curve from path
+        const path_component = this.path;
+
+        const three_points = [];
+
+        const pointCount = path_component.getPointCount();
+
+        if (pointCount < 2) {
+            // no curve possible without at least 2 points
+            return;
+        }
+
+        for (let i = 0; i < pointCount; i++) {
+            const v3 = new Vector3();
+
+            path_component.getPosition(i, v3);
+
+            three_points.push(v3);
+        }
+
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        let geometry;
+
+        if (path_component.interpolation === InterpolationType.Linear) {
+            geometry = build_geometry_linear(three_points, pointCount, style);
+        } else if (path_component.interpolation === InterpolationType.CatmullRom) {
+            geometry = build_geometry_catmullrom(three_points, pointCount, style);
+        } else {
+            throw new Error(`Unsupported interpolation type '${path_component.interpolation}'`);
+        }
+
+
+        let material_def;
+
+        if (style.material_type === TubeMaterialType.Standard) {
+            material_def = new MeshStandardMaterial({
+                metalness: style.material.metalness,
+                roughness: style.material.roughness
+            });
+        } else if (style.material_type === TubeMaterialType.Matcap) {
+
+            material_def = new MeshMatcapMaterial();
+
+            this.assetManager.get(style.material.texture, GameAssetType.Texture, asset => {
+                material_def.matcap = asset.create();
+
+                material_def.needsUpdate = true;
+            }, console.error);
+
+        } else {
+            throw new Error(`Unsupported material type '${style.material_type}'`);
+        }
+
+        material_def.color.set(style.color.toUint());
+
+        if (style.opacity < 1) {
+            material_def.transparent = true;
+            material_def.opacity = style.opacity;
+        }
+
+        const entityBuilder = new EntityBuilder();
+
+        entityBuilder.add(new Transform());
+
+        const shaded_geometry = ShadedGeometry.from(geometry, material_def);
+
+        shaded_geometry.writeFlag(ShadedGeometryFlags.CastShadow, style.cast_shadow);
+        shaded_geometry.writeFlag(ShadedGeometryFlags.ReceiveShadow, style.receive_shadow);
+
+        entityBuilder.add(shaded_geometry);
+
+        destination.push(entityBuilder);
+    }
+}