@woosh/meep-engine 2.35.14 → 2.35.17

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

@@ -0,0 +1,390 @@
+import { EngineHarness } from "../../../../EngineHarness.js";
+import { EngineConfiguration } from "../../../../EngineConfiguration.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
+import HeadsUpDisplaySystem from "../../../../ecs/gui/hud/HeadsUpDisplaySystem.js";
+import ScriptSystem from "../../../../ecs/systems/ScriptSystem.js";
+import FacingDirectionSystem from "../../../../../../model/game/ecs/system/FacingDirectionSystem.js";
+import PathFollowingSystem from "../../../../navigation/ecs/path_following/PathFollowingSystem.js";
+import SteeringSystem from "../../../../ecs/systems/SteeringSystem.js";
+import MotionSystem from "../../../../ecs/systems/MotionSystem.js";
+import TagSystem from "../../../../ecs/systems/TagSystem.js";
+import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
+import { SoundEmitterSystem } from "../../../../sound/ecs/emitter/SoundEmitterSystem.js";
+import SoundControllerSystem from "../../../../sound/ecs/SoundControllerSystem.js";
+import SoundListenerSystem from "../../../../sound/ecs/SoundListenerSystem.js";
+import TimerSystem from "../../../../ecs/systems/TimerSystem.js";
+import AnimationSystem from "../../../../ecs/systems/AnimationSystem.js";
+import TopDownCameraControllerSystem from "../../camera/topdown/TopDownCameraControllerSystem.js";
+import { TopDownCameraLanderSystem } from "../../camera/topdown/TopDownCameraLanderSystem.js";
+import { CameraSystem } from "../../camera/CameraSystem.js";
+import { MeshSystem } from "../../mesh/MeshSystem.js";
+import ClingToTerrainSystem from "../../../../ecs/terrain/ecs/ClingToTerrainSystem.js";
+import TerrainSystem from "../../../../ecs/terrain/ecs/TerrainSystem.js";
+import WaterSystem from "../../water/WaterSystem.js";
+import Trail2DSystem from "../../trail2d/Trail2DSystem.js";
+import { Foliage2System } from "../../../../ecs/foliage/ecs/Foliage2System.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import { GridPosition2TransformSystem } from "../../../../grid/systems/GridPosition2TransformSystem.js";
+import { Transform2GridPositionSystem } from "../../../../grid/transform2grid/Transform2GridPositionSystem.js";
+import SynchronizePositionSystem from "../../../../ecs/systems/SynchronizePositionSystem.js";
+import GridObstacleSystem from "../../../../grid/systems/GridObstacleSystem.js";
+import GridPositionSystem from "../../../../grid/systems/GridPositionSystem.js";
+import InputControllerSystem from "../../../../input/ecs/systems/InputControllerSystem.js";
+import { InputSystem } from "../../../../input/ecs/systems/InputSystem.js";
+import MeshHighlightSystem from "../../highlight/system/MeshHighlightSystem.js";
+import LightSystem from "../../light/LightSystem.js";
+import AnimationControllerSystem from "../../animation/AnimationControllerSystem.js";
+import { AnimationGraphSystem } from "../../animation/animator/AnimationGraphSystem.js";
+import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { SerializationMetadataSystem } from "../../../../ecs/systems/SerializationMetadataSystem.js";
+import { InverseKinematicsSystem } from "../../../../ecs/animation/InverseKinematicsSystem.js";
+import { PathDisplaySystem } from "../PathDisplaySystem.js";
+import { AmbientOcclusionPostProcessEffect } from "../../../render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import { GameAssetType } from "../../../../asset/GameAssetType.js";
+import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
+import { JsonAssetLoader } from "../../../../asset/loaders/JsonAssetLoader.js";
+import { TextureAssetLoader } from "../../../../asset/loaders/texture/TextureAssetLoader.js";
+import { ImageRGBADataLoader } from "../../../../asset/loaders/image/ImageRGBADataLoader.js";
+import { ShadedGeometrySystem } from "../../mesh-v2/ShadedGeometrySystem.js";
+import { makeEngineOptionsModel } from "../../../../../../model/game/options/makeEngineOptionsModel.js";
+import { enableEditor } from "../../../../../editor/enableEditor.js";
+import { CanvasView } from "../../../../../view/elements/CanvasView.js";
+import { computeCatmullRomSpline } from "../../../../navigation/ecs/components/computeCatmullRomSpline.js";
+import { EntityPathStyle } from "../entity/EntityPathStyle.js";
+import { EntityPathMarkerDefinition } from "../entity/EntityPathMarkerDefinition.js";
+import { EntityBlueprint } from "../../../../ecs/EntityBlueprint.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import Mesh from "../../mesh/Mesh.js";
+import { Animation } from "../../../../ecs/animation/Animation.js";
+import Highlight from "../../highlight/Highlight.js";
+import { TubePathStyle } from "./TubePathStyle.js";
+import { TubeMaterialType } from "./TubeMaterialType.js";
+import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
+import Path from "../../../../navigation/ecs/components/Path.js";
+import { InterpolationType } from "../../../../navigation/ecs/components/InterpolationType.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { RibbonPathStyle } from "../ribbon/RibbonPathStyle.js";
+import { PathDisplay } from "../PathDisplay.js";
+import { PathDisplaySpec } from "../PathDisplaySpec.js";
+import { PathDisplayType } from "../PathDisplayType.js";
+import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
+import { pingpong } from "../../../../../core/math/pingpong.js";
+import { PathEvents } from "../../../../navigation/ecs/components/PathEvents.js";
+
+const engineHarness = new EngineHarness();
+
+function makeConfig(engine) {
+
+    const config = new EngineConfiguration();
+
+    /**
+     *
+     * @type {SoundEngine}
+     */
+    const sound = engine.sound;
+    const graphics = engine.graphics;
+    const assetManager = engine.assetManager;
+    const devices = engine.devices;
+
+    const guiSystem = new GUIElementSystem(engine.gui.view, engine);
+    const headsUpDisplaySystem = new HeadsUpDisplaySystem(graphics);
+
+    config.systems.push(
+        new ScriptSystem(),
+        new FacingDirectionSystem(),
+        new PathFollowingSystem(),
+        new SteeringSystem(),
+        new MotionSystem(),
+        new TagSystem(),
+        new AttachmentSystem(),
+        new SoundEmitterSystem(assetManager, sound.destination, sound.context),
+        new SoundControllerSystem(),
+        new SoundListenerSystem(sound.context),
+        new TimerSystem(),
+        guiSystem,
+        new AnimationSystem(graphics.viewport.size),
+        new TopDownCameraControllerSystem(graphics),
+        new TopDownCameraLanderSystem(),
+        new CameraSystem(graphics.scene, graphics),
+        new MeshSystem(engine),
+        new ClingToTerrainSystem(),
+        new TerrainSystem(graphics, assetManager),
+        new WaterSystem(graphics),
+        new Trail2DSystem(engine),
+        new Foliage2System(assetManager, graphics),
+        new ViewportPositionSystem(graphics.viewport.size),
+        new GridPosition2TransformSystem(),
+        new Transform2GridPositionSystem(),
+        new SynchronizePositionSystem(),
+        new GridObstacleSystem(),
+        new GridPositionSystem(),
+        new InputControllerSystem(devices),
+        new InputSystem(devices),
+        new MeshHighlightSystem(engine),
+        new LightSystem(engine, {
+            shadowResolution: 1024
+        }),
+        new AnimationControllerSystem(),
+        new AnimationGraphSystem(graphics.viewport.size),
+        headsUpDisplaySystem,
+        new BehaviorSystem(engine),
+        new SerializationMetadataSystem(),
+        new InverseKinematicsSystem(),
+        new PathDisplaySystem(engine),
+    );
+
+    // Plugins
+
+    config.addPlugin(AmbientOcclusionPostProcessEffect)
+
+    // Knowledge
+
+    // Assets
+
+    config.addLoader(GameAssetType.ModelGLTF, new GLTFAssetLoader());
+    config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
+    config.addLoader(GameAssetType.JSON, new JsonAssetLoader());
+    config.addLoader(GameAssetType.Texture, new TextureAssetLoader());
+    config.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
+
+    return config;
+}
+
+/**
+ *
+ * @param {EngineHarness} harness
+ * @return {Promise<void>}
+ */
+async function init(harness) {
+    const engine = harness.engine;
+
+    // engine.entityManager.addSystem(new RenderSystem(engine.graphics));
+    engine.entityManager.addSystem(new ShadedGeometrySystem(engine));
+
+    makeEngineOptionsModel(engine.options, engine);
+
+    await makeConfig(engine).apply(engine);
+
+    enableEditor(engine);
+
+    await harness.initialize();
+
+    main(engine);
+}
+
+function catmullRom(points) {
+    const cv = new CanvasView();
+
+    cv.size.set(500, 500);
+
+    cv.link();
+
+    cv.css({
+        position: "absolute",
+        left: 0,
+        right: 0,
+        zIndex: 99999
+    });
+
+    const sample = [];
+
+    const ctx = cv.context2d;
+    ctx.strokeStyle = "rgba(255,255,255,1)";
+    ctx.lineWidth = 2;
+    ctx.beginPath();
+
+    const draw_scale = 50;
+
+    const result = [];
+    const sampleCount = 50;
+
+    computeCatmullRomSpline(result, points, points.length / 3, 3, sampleCount, 0.5);
+
+    for (let i = 0; i < sampleCount; i++) {
+        const x = result[i * 3];
+        const y = result[i * 3 + 1];
+        const z = result[i * 3 + 2];
+
+        ctx.lineTo(x * draw_scale, z * draw_scale);
+
+    }
+    ctx.stroke();
+
+    document.body.appendChild(cv.el);
+}
+
+function sample_style_entity() {
+    const style = new EntityPathStyle();
+    style.spacing = 0.6;
+    style.marker_start = EntityPathMarkerDefinition.from({
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/arrow-symbols/arrow4/model-green.gltf",
+                castShadow: true,
+                receiveShadow: true
+            })
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.3,
+                y: 0.3,
+                z: 0.3
+            },
+            rotation: {
+                x: 0.5,
+                y: -0.5,
+                z: 0.5,
+                w: 0.5
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
+    style.marker_end = EntityPathMarkerDefinition.from({
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/arrow-symbols/arrow4/model-red.gltf",
+                castShadow: true,
+                receiveShadow: true
+            })
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.3,
+                y: 0.3,
+                z: 0.3
+            },
+            rotation: {
+                x: 0.5,
+                y: -0.5,
+                z: 0.5,
+                w: 0.5
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
+    style.marker_main = EntityPathMarkerDefinition.from({
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/Barel-Roll Droid/handpainted.gltf",
+                castShadow: true,
+                receiveShadow: true
+            }),
+            Animation.fromJSON({
+                clips: [
+                    {
+                        name: "fly",
+                        repeatCount: Infinity
+                    }
+                ]
+            }),
+            Highlight.fromOne(1, 0, 0, 1)
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.2,
+                y: 0.2,
+                z: 0.2
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
+
+    return style;
+}
+
+function sample_style_tube() {
+    const style = new TubePathStyle();
+
+    style.color.setRGB(1, 1, 1);
+    style.material_type = TubeMaterialType.Matcap;
+    style.material = new MatcapMaterialDefinition();
+    // style.material.texture = 'data/textures/matcap/matcap-porcelain-white.jpg';
+    style.material.texture = "data/textures/matcap/nidorx/3E2335_D36A1B_8E4A2E_2842A5.jpg";
+
+    style.width = 0.1;
+
+    style.path_mask = [
+        0, 1,
+    ];
+
+    return style;
+}
+
+
+function main(engine) {
+    EngineHarness.buildBasics({ engine });
+
+    const _p = new Path();
+    _p.interpolation = InterpolationType.CatmullRom;
+    // _p.interpolation = InterpolationType.Linear;
+
+    // _p.setPositionsFromVectorArray(Path.smoothPath([
+    //     new Vector3(3, 1, 1),
+    //     new Vector3(3, 1, 3),
+    //     new Vector3(7, 1, 3),
+    //     new Vector3(7, 1, 7),
+    //     new Vector3(3, 1, 7),
+    //     new Vector3(3, 1, 8),
+    // ], 50));
+
+    _p.setPositionsFromVectorArray([
+        new Vector3(3, 1, 1),
+        new Vector3(3, 1, 3),
+        new Vector3(7, 1, 3),
+        new Vector3(7, 1, 7),
+        new Vector3(3, 1, 7),
+        new Vector3(3, 1, 8),
+    ]);
+
+
+    const trailPathStyle = new RibbonPathStyle();
+    trailPathStyle.material.diffuse = "data/textures/trail/Circle_04.png";
+    trailPathStyle.resolution = 10;
+    trailPathStyle.thickness = 0.1;
+
+    const pathDisplay = new PathDisplay();
+    const tube_style = sample_style_tube();
+    pathDisplay.specs.push(
+        PathDisplaySpec.from(
+            PathDisplayType.Tube,
+            tube_style
+        )
+    );
+
+
+    const path_entity = new EntityBuilder();
+
+    const ecd = engine.entityManager.dataset;
+    path_entity
+        .add(_p)
+        .add(pathDisplay)
+        .build(ecd);
+
+    let time = 0;
+    new EntityBuilder()
+        .add(BehaviorComponent.looping_function((delta) => {
+            time += delta*0.01;
+            tube_style.path_mask[1] = pingpong(time, 1);
+
+            path_entity.sendEvent(PathEvents.Changed);
+        }))
+        .build(ecd)
+}
+
+init(engineHarness);

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -56,6 +56,22 @@ export class GeometrySpatialQueryAccelerator {
         return this.__visitor_clip.getContainment();
     }
 
+    /**
+     *
+     * @param {SurfacePoint3} destination
+     * @param {THREE.BufferGeometry} geometry
+     * @param {number[]|ArrayLike<number>|Float32Array} ray 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+     * @return {boolean}
+     */
+    queryRaycastNearest_array(destination, geometry, ray) {
+        return this.queryRaycastNearest_primitive(
+            destination,
+            geometry,
+            ray[0], ray[1], ray[2],
+            ray[3], ray[4], ray[5]
+        );
+    }
+
     /**
      *
      * @param {SurfacePoint3} destination

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

@@ -1,10 +1,3 @@
-/**
- *
- * @param {number} count
- * @returns {Function}
- * @constructor
- */
-
 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";
@@ -12,17 +5,7 @@ import { compute_micron_buffer_array_constructor } from "./compute_micron_buffer
 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) {
-
-    if (count <= 256) {
-        return Uint8Array;
-    } else if (count <= 65536) {
-        return Uint16Array;
-    } else {
-        throw new Error(`Unsupported size ${count}`)
-    }
-}
+import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
 
 /**
  * @param {number} vertex_count

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

@@ -5,6 +5,7 @@ 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";
 import { BitSet } from "../../../../core/binary/BitSet.js";
+import { micron_build_proxy_geometry } from "./micron_build_proxy_geometry.js";
 
 let id_counter = 0;
 
@@ -286,11 +287,13 @@ export class MicronGeometry {
 
     /**
      * Build geometry proxy from the patches
-     * @param {number} fraction percentage of the original geometry to keep
-     * @param {number} min minimum number of triangles to keep, this will be respected first before percentage value
+     * @param {number} [fraction] percentage of the original geometry to keep
+     * @param {number} [min] minimum number of triangles to keep, this will be respected first before percentage value
      */
-    buildProxy(fraction, min) {
-        throw new Error('Not Implemented');
+    buildProxy(fraction = 0.05, min = 2048) {
+        const bufferGeometry = micron_build_proxy_geometry(this, fraction, min);
+
+        this.__proxy = bufferGeometry;
     }
 
     computeByteSize() {

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

@@ -0,0 +1,203 @@
+//
+
+import BinaryHeap from "../../../navigation/grid/FastBinaryHeap.js";
+import { BufferAttribute, BufferGeometry } from "three";
+import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
+import { compute_typed_array_constructor_from_data_type } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { BitSet } from "../../../../core/binary/BitSet.js";
+import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+/**
+ *
+ * @param {MicronGeometry} micron_geometry
+ * @param {number} fraction
+ * @param {number} min_face_count
+ * @returns {MicronGeometryPatch[]}
+ */
+function collect_patches(micron_geometry, fraction, min_face_count) {
+    /**
+     *
+     * @type {BinaryHeap<MicronGeometryPatch>}
+     */
+    const heap = new BinaryHeap(patch => {
+        // LOD is a good proxy for how much detail there is in a patch
+        return -patch.lod;
+    });
+
+    let closed_set = new BitSet();
+
+    let current_polycount = 0;
+
+    /**
+     *
+     * @param {MicronGeometryPatch} patch
+     */
+    function add(patch) {
+
+        closed_set.set(patch.id, true);
+
+        heap.push(patch);
+
+        current_polycount += patch.polygon_count;
+    }
+
+    /**
+     *
+     * @param {MicronGeometryPatch} patch
+     */
+    function refine(patch) {
+        const children = patch.children;
+        const child_count = children.length;
+
+
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            if (closed_set.get(child.id)) {
+                // already refined
+                continue;
+            }
+
+            add(child);
+
+            const parents = child.parents;
+
+            const parent_count = parents.length;
+            for (let j = 0; j < parent_count; j++) {
+                const parent = parents[j];
+
+                if (parent === parent) {
+                    continue;
+                }
+
+                // remove and refine other patches in the same group
+                if (heap.delete(parent)) {
+                    refine(parent);
+                }
+            }
+        }
+    }
+
+    add(micron_geometry.root);
+
+    const target_polycount_threshold = max2(
+        micron_geometry.source_triangle_count * fraction,
+        min2(
+            min_face_count,
+            micron_geometry.source_triangle_count
+        )
+    );
+
+    while (current_polycount < target_polycount_threshold) {
+        const p = heap.peek();
+
+        if (p === undefined || p.lod === 0) {
+            // no refinement possible
+            break;
+        }
+
+        heap.pop();
+
+        current_polycount -= p.polygon_count;
+
+        refine(p);
+    }
+
+    const result = [];
+
+    // collect
+    while (!heap.isEmpty()) {
+        result.push(heap.pop());
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {MicronGeometryPatch[]} patches
+ * @param {VertexDataSpec} vertex_spec
+ * @returns {THREE.BufferGeometry}
+ */
+function assemble_patches_to_geometry(patches, vertex_spec) {
+    const geo = new BufferGeometry();
+
+    //compute total number of vertices and faces
+    let total_faces = 0;
+    let total_vertices = 0;
+
+    for (let i = 0; i < patches.length; i++) {
+        const patch = patches[i];
+
+        total_faces += patch.polygon_count;
+        total_vertices += patch.vertex_count;
+    }
+
+    const index_data = new (UintArrayForCount(total_vertices))(total_faces * 3);
+
+    geo.setIndex(new BufferAttribute(index_data, 1, false));
+
+    const attribute_arrays = [];
+
+    const attribute_specs = vertex_spec.attributes;
+    const attribute_count = attribute_specs.length;
+    for (let i = 0; i < attribute_count; i++) {
+        const attribute = attribute_specs[i];
+
+        const TA = compute_typed_array_constructor_from_data_type(attribute.type);
+
+        const attribute_data = new TA(total_vertices * 3);
+
+        attribute_arrays[i] = attribute_data;
+
+        geo.setAttribute(attribute.name, new BufferAttribute(attribute_data, attribute.itemSize, attribute.normalized));
+    }
+
+    let index_cursor = 0;
+    let vertex_cursor = 0;
+
+    // add patches to resulting geometry
+    for (let i = 0; i < patches.length; i++) {
+        const patch = patches[i];
+
+        const local_index_size = patch.polygon_count * 3;
+
+        // copy transformed indices
+        for (let j = 0; j < local_index_size; j++) {
+            const local_index = patch.face_indices[j];
+
+            index_data[index_cursor + j] = local_index + vertex_cursor;
+        }
+
+        // copy vertex data
+
+        for (let j = 0; j < attribute_count; j++) {
+            const attribute_destination = attribute_arrays[j];
+
+            const attribute_source = patch.vertex_attribute_arrays[j];
+            const destination_offset = vertex_cursor * attribute_specs[j].itemSize;
+
+            attribute_destination.set(attribute_source, destination_offset);
+        }
+
+        vertex_cursor += patch.vertex_count;
+        index_cursor += local_index_size;
+    }
+
+    return geo;
+}
+
+
+/**
+ *
+ * @param {MicronGeometry} micron_geometry
+ * @param {number} fraction
+ * @param {number} [min_face_count]
+ * @returns {THREE.BufferGeometry}
+ */
+export function micron_build_proxy_geometry(micron_geometry, fraction, min_face_count = 128) {
+    const patches = collect_patches(micron_geometry, fraction, min_face_count);
+
+    return assemble_patches_to_geometry(patches, micron_geometry.vertex_spec);
+}