@woosh/meep-engine 2.33.20 → 2.33.24

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -0,0 +1,558 @@
+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 { AttachmentSocketsSystem } from "../../../../../../ecs/sockets/AttachmentSocketsSystem.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 "../../../../../ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { TopDownCameraLanderSystem } from "../../../../../ecs/camera/topdown/TopDownCameraLanderSystem.js";
+import { CameraSystem } from "../../../../../ecs/camera/CameraSystem.js";
+import { MeshSystem } from "../../../../../ecs/mesh/MeshSystem.js";
+import ClingToTerrainSystem from "../../../../../../ecs/terrain/ecs/ClingToTerrainSystem.js";
+import TerrainSystem from "../../../../../../ecs/terrain/ecs/TerrainSystem.js";
+import WaterSystem from "../../../../../ecs/water/WaterSystem.js";
+import Trail2DSystem from "../../../../../ecs/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 "../../../../../ecs/highlight/system/MeshHighlightSystem.js";
+import LightSystem from "../../../../../ecs/light/LightSystem.js";
+import AnimationControllerSystem from "../../../../../ecs/animation/AnimationControllerSystem.js";
+import { AnimationGraphSystem } from "../../../../../ecs/animation/animator/AnimationGraphSystem.js";
+import { FogOfWarSystem } from "../../../../../../ecs/fow/FogOfWarSystem.js";
+import { FogOfWarRevealerSystem } from "../../../../../../ecs/fow/FogOfWarRevealerSystem.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 "../../../../../ecs/path/PathDisplaySystem.js";
+import { MicronRenderPlugin } from "../../../../../micron/plugin/MicronRenderPlugin.js";
+import RenderSystem from "../../../../../../ecs/systems/RenderSystem.js";
+import { makeEngineOptionsModel } from "../../../../../../../../model/game/options/makeEngineOptionsModel.js";
+import { enableEditor } from "../../../../../../../editor/enableEditor.js";
+import { buildCubeURLs } from "../../../../../texture/cubemap/buildCubeURLs.js";
+import { AmbientOcclusionPostProcessEffect } from "../../../../../render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import Vector2 from "../../../../../../../core/geom/Vector2.js";
+import Vector3 from "../../../../../../../core/geom/Vector3.js";
+import EntityBuilder from "../../../../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../../../../ecs/transform/Transform.js";
+import Mesh from "../../../../../ecs/mesh/Mesh.js";
+import { AABB3 } from "../../../../../../../core/bvh2/aabb3/AABB3.js";
+import { ParticleVolume } from "./ParticleVolume.js";
+import { ParticleEmitterSystem2 } from "../../../../ecs/ParticleEmitterSystem2.js";
+import { BehaviorComponent } from "../../../../../../intelligence/behavior/ecs/BehaviorComponent.js";
+import { RepeatBehavior } from "../../../../../../intelligence/behavior/decorator/RepeatBehavior.js";
+import { ActionBehavior } from "../../../../../../intelligence/behavior/primitive/ActionBehavior.js";
+import { pingpong } from "../../../../../../../core/math/pingpong.js";
+import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
+import { pick } from "../../../../../../../../model/game/util/ScreenGridPicker.js";
+import { obtainTerrain } from "../../../../../../../../model/game/scenes/SceneUtils.js";
+import GUIElement from "../../../../../../ecs/gui/GUIElement.js";
+import EmptyView from "../../../../../../../view/elements/EmptyView.js";
+import HeadsUpDisplay from "../../../../../../ecs/gui/hud/HeadsUpDisplay.js";
+import ViewportPosition from "../../../../../../ecs/gui/position/ViewportPosition.js";
+import { Sampler2D } from "../../../../../texture/sampler/Sampler2D.js";
+import { CanvasView } from "../../../../../../../view/elements/CanvasView.js";
+import convertSampler2D2Canvas from "../../../../../texture/sampler/Sampler2D2Canvas.js";
+import Vector1 from "../../../../../../../core/geom/Vector1.js";
+import { clamp } from "../../../../../../../core/math/clamp.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 AttachmentSocketsSystem(),
+        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: 2048
+        }),
+        new AnimationControllerSystem(),
+        new AnimationGraphSystem(graphics.viewport.size),
+        headsUpDisplaySystem,
+        new FogOfWarSystem(graphics),
+        new FogOfWarRevealerSystem(0),
+        new BehaviorSystem(engine),
+        new SerializationMetadataSystem(),
+        new InverseKinematicsSystem(),
+        new PathDisplaySystem(engine),
+    );
+
+
+    // Plugins
+    config.addPlugin(MicronRenderPlugin);
+
+
+    // Knowledge
+
+    return config;
+}
+
+
+/**
+ *
+ * @param {EngineHarness} harness
+ * @return {Promise<void>}
+ */
+async function init(harness) {
+    const engine = harness.engine;
+
+    engine.entityManager.addSystem(new RenderSystem(engine.graphics));
+
+    makeEngineOptionsModel(engine.options, engine);
+
+    await makeConfig(engine).apply(engine);
+
+    enableEditor(engine);
+
+    await engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
+
+
+    await engine.plugins.acquire(AmbientOcclusionPostProcessEffect);
+
+    await harness.initialize();
+
+    main(engine);
+}
+
+
+const heatmap_lut_0 = new ParameterLookupTable(4);
+heatmap_lut_0.write([
+    0, 0, 255, 10,
+    0, 179, 179, 10,
+    0, 255, 0, 10,
+    255, 255, 0, 10,
+    255, 5, 5, 10
+]);
+heatmap_lut_0.computeUniformPositions();
+
+const heatmap_lut_1 = new ParameterLookupTable(4);
+heatmap_lut_1.write([
+    255, 127, 0, 100,
+    206, 2, 86, 100
+]);
+heatmap_lut_1.computeUniformPositions();
+
+const heatmap_lut_2 = new ParameterLookupTable(4);
+heatmap_lut_2.write([
+    255, 151, 213, 50,
+    2, 243, 255, 50
+]);
+heatmap_lut_2.computeUniformPositions();
+
+const heatmap_lut_3 = new ParameterLookupTable(4);
+heatmap_lut_3.write(
+    [
+        196, 196, 196, 255,
+        196, 196, 196, 255,
+        0, 230, 0, 255,
+        0, 230, 0, 255,
+        255, 212, 0, 255,
+        255, 212, 0, 255,
+    ],
+    [
+        0,
+        0.1,
+        0.1,
+        0.7,
+        0.7,
+        1
+    ]
+);
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+    EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        // enableTerrain: false,
+        enableTerrain: true,
+        terrainSize: new Vector2(100, 100),
+        focus: new Vector3(102, 0, 61),
+        // pitch: -0.5,
+        // yaw: 2.2,
+        // distance: 3
+        pitch: 0.9,
+        yaw: 3.1,
+        distance: 20
+    });
+
+
+    engine.graphics.renderer.setClearColor('rgba(99,99,99,1)');
+
+
+    const ecd = engine.entityManager.dataset;
+
+    new EntityBuilder()
+        .add(Transform.fromJSON({
+            position: {
+                x: 20,
+                y: -5.8,
+                z: 100
+            },
+            scale: {
+                x: 1,
+                y: 1,
+                z: 1
+            }
+        }))
+        .add(Mesh.fromJSON({
+            url: 'data/models/moicon/05-ground-floor/model.gltf',
+            castShadow: true,
+            receiveShadow: true
+        }))
+        // .build(ecd);
+    new EntityBuilder()
+        .add(Transform.fromJSON({
+            position: {
+                x: 20,
+                y: -5.8,
+                z: 100
+            },
+            scale: {
+                x: 1,
+                y: 1,
+                z: 1
+            }
+        }))
+        .add(Mesh.fromJSON({
+            url: 'data/models/moicon/08-clickable-assets/model.gltf',
+            castShadow: true,
+            receiveShadow: true
+        }))
+        // .build(ecd);
+
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_0,
+        bounds: new AABB3(67.73, 0, 89, 115.84, 3, 118.34),
+        particle_size: 4,
+        density: 4,
+        period: 10
+    });
+
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_0,
+        bounds: new AABB3(43.8, 0, 89, 67.40, 3, 131),
+        particle_size: 2,
+        density: 1,
+        period: 10,
+        period_offset: 3,
+    });
+
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_1,
+        bounds: new AABB3(97.68, 0, 67.71, 115.76, 3, 76.14),
+        particle_size: 1,
+        density: 1.2,
+        period: 7,
+        period_offset: 2,
+    });
+
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_2,
+        bounds: new AABB3(79.0, 0, 67.71, 97.35, 3, 76.14),
+        particle_size: 4,
+        density: 4,
+        period: 7,
+        period_offset: 2,
+    });
+
+    await make_demo_volume({
+        ecd: ecd,
+        lut: heatmap_lut_3,
+        bounds: new AABB3(67.85, 0, 31.1, 109.8, 3, 67.02),
+        particle_size: 0.1,
+        density: 5,
+        period: 7,
+        period_offset: 2,
+    });
+
+    engine.devices.pointer.on.down.add((p) => {
+        pick(p.x, p.y, engine.graphics, obtainTerrain(ecd), (grid_position, position, normal) => {
+            console.log(position.toJSON());
+        });
+    });
+}
+
+/**
+ *
+ * @param {ParameterLookupTable} lut
+ * @param {number} width
+ * @param {number} height
+ * @returns {Sampler2D}
+ */
+function lut_to_sampler(lut, width, height) {
+    const sampler = Sampler2D.uint8(4, width, height);
+
+    const s = [];
+
+    for (let i = 0; i < width; i++) {
+
+        lut.sample(i / (width - 1), s);
+        s[3] = 255;
+
+        for (let j = 0; j < height; j++) {
+            sampler.set(i, j, s);
+        }
+
+    }
+
+    return sampler;
+}
+
+async function create_volume({
+                                 bounds = new AABB3(0, 0, 0, 1, 1, 1),
+                                 density = 10,
+                                 particle_size = 1
+                             }) {
+
+    const aabb_bounds = new AABB3();
+    aabb_bounds.fromJSON(bounds);
+
+    const hs = particle_size / 4;
+
+    aabb_bounds.x0 += hs;
+    aabb_bounds.z0 += hs;
+
+    aabb_bounds.x1 -= hs;
+    aabb_bounds.z1 -= hs;
+
+    const adjusted_density = density / particle_size;
+
+    const v = new ParticleVolume();
+
+    const dx = aabb_bounds.x1 - aabb_bounds.x0;
+    const dy = aabb_bounds.y1 - aabb_bounds.y0;
+    const dz = aabb_bounds.z1 - aabb_bounds.z0;
+
+    v.transform.scale.set(
+        dx,
+        dy,
+        dz
+    );
+
+    v.transform.position.set(
+        aabb_bounds.x0 + dx / 2,
+        aabb_bounds.y0 + dy / 2,
+        aabb_bounds.z0 + dz / 2
+    );
+
+
+    const em = engine.entityManager;
+
+    if (em.getSystem(ParticleEmitterSystem2) === null) {
+        await em.addSystem(new ParticleEmitterSystem2(engine.assetManager, engine.graphics));
+    }
+
+    v.from({
+        density: adjusted_density,
+        particle_size
+    });
+
+    v.build();
+
+    v.entity.build(em.dataset);
+
+    return v;
+}
+
+/**
+ *
+ * @param {AABB3} bounds
+ * @param {ParameterLookupTable} lut
+ * @return {{position: Vector1}}
+ */
+function make_symbol_view({
+                              bounds,
+                              lut
+                          }) {
+
+    const r = {
+        position: new Vector1(1)
+    };
+
+    const symbol_view = new EmptyView();
+    symbol_view.size.set(128, 20);
+
+    symbol_view.css({
+        position: 'absolute',
+        whiteSpace: 'pre',
+        left: 0,
+        top: 0
+    });
+
+    const view_lut = new CanvasView();
+    view_lut.size.set(128, 10);
+    view_lut.css({
+        position: 'absolute',
+        border: '1px solid white',
+        boxShadow: '0 0 6px rgba(0,0,0,0.4)',
+        left: 0,
+        top: 0
+    });
+
+    const sampler_lut = lut_to_sampler(lut, view_lut.size.x, view_lut.size.y);
+
+    convertSampler2D2Canvas(sampler_lut, 1, 0, view_lut.el);
+
+    symbol_view.addChild(view_lut)
+
+    const view_cursor = new EmptyView();
+
+    view_cursor.css({
+        position: 'absolute',
+        left: 0,
+        top: "-1px",
+        height: "10px",
+        width: "4px",
+        border: '2px solid white',
+        zIndex: 2,
+        boxShadow: '0 0 4px black'
+    });
+
+
+    r.position.process(f => {
+        const c = new Uint8Array(4);
+
+        lut.sample(f, c);
+
+        const hex_string = `rgb(${c[0]},${c[1]},${c[2]})`;
+
+        view_cursor.position.set(f * view_lut.size.x, 0);
+        view_cursor.css({
+            backgroundColor: hex_string
+        })
+    });
+
+    symbol_view.addChild(view_cursor);
+
+    const symbol_transform = new Transform();
+    bounds.getCenter(symbol_transform.position);
+
+    const vp = new ViewportPosition();
+    vp.anchor.set(0.5, 1);
+
+    const entity = new EntityBuilder()
+        .add(GUIElement.fromView(symbol_view))
+        .add(new HeadsUpDisplay())
+        .add(vp)
+        .add(symbol_transform);
+
+    r.entity = entity;
+
+    return r;
+}
+
+async function make_demo_volume({
+                                    ecd,
+                                    bounds = new AABB3(0, 0, 0, 20, 10, 20),
+                                    lut,
+                                    period = 5,
+                                    period_offset = 0,
+                                    density,
+                                    particle_size
+                                }) {
+
+    const v = await create_volume({
+        bounds,
+        density,
+        particle_size
+    });
+
+    let time_total = 0;
+
+    const symbol = make_symbol_view({
+        bounds,
+        lut
+    });
+
+    symbol.entity.build(ecd);
+
+    new EntityBuilder()
+        .add(BehaviorComponent.fromOne(RepeatBehavior.from(new ActionBehavior((time) => {
+            time_total += time;
+
+            const _t = pingpong(time_total + period_offset, period);
+
+            const f = clamp(_t / period, 0, 1);
+
+            symbol.position.set(f);
+
+            const s = [];
+            lut.sample(f, s);
+
+            // console.log(JSON.stringify(s));
+
+            v.setColor(s[0] , s[1] , s[2] , s[3] );
+        }))))
+        .build(ecd);
+}
+
+init(engineHarness);

package/engine/graphics/particles/particular/group/Operation.js

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {OperationType} operator
+ * @param {Array} operands
+ * @constructor
+ */
+export function Operation(operator, operands) {
+    /**
+     *
+     * @type {OperationType}
+     */
+    this.operator = operator;
+    /**
+     *
+     * @type {Array}
+     */
+    this.operands = operands;
+}

package/engine/graphics/particles/particular/group/OperationType.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @enum {number}
+ */
+export const OperationType = {
+    Remove: 0,
+    Add: 1,
+    WriteAttribute: 2
+};

package/engine/graphics/particles/particular/group/ParticleAttribute.js

@@ -3,6 +3,7 @@
  * @param {string} name
  * @param {ParticleAttributeType} attributeType
  * @param {ParticleDataType} dataType
+ * @deprecated use {@link AttributeSpec} instead
  * @constructor
  */
 export function ParticleAttribute(name, attributeType, dataType) {
@@ -21,4 +22,4 @@ export function ParticleAttribute(name, attributeType, dataType) {
      * @type {ParticleDataType}
      */
     this.dataType = dataType;
-}
+}

package/engine/graphics/particles/particular/group/ParticleAttributeType.js

@@ -0,0 +1,11 @@
+/**
+ *
+ * @enum {number}
+ */
+const ParticleAttributeType = {
+    Scalar: 1,
+    Vector2: 2,
+    Vector3: 3,
+    Vector4: 4
+};
+export { ParticleAttributeType };

package/engine/graphics/particles/particular/group/ParticleDataType.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @enum {number}
+ */
+const ParticleDataType = {
+    Float32: 0,
+    Float64: 1,
+    Uint8: 2
+};
+export { ParticleDataType };