@woosh/meep-engine 2.33.69 → 2.33.73

package/core/geom/3d/eulerAnglesFromMatrix.js

@@ -0,0 +1,115 @@
+//
+
+import { v2_magnitude } from "../Vector2.js";
+
+function atan2(a, b) {
+    return Math.atan2(a, b);
+}
+
+/**
+ *
+ * @param {number[]} mat4
+ * @param {number} row_index
+ * @param {number} column_index
+ * @return {number}
+ */
+function coeff(mat4, row_index, column_index) {
+    return mat4[row_index + column_index * 4];
+}
+
+function sin(a) {
+    return Math.sin(a);
+}
+
+function cos(a) {
+    return Math.cos(a);
+}
+
+const EIGEN_PI = Math.PI;
+
+/**
+ *
+ * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2)
+ *
+ * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}.
+ * For instance, in:
+ * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode
+ * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
+ * we have the following equality:
+ * \code
+ * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
+ *      * AngleAxisf(ea[1], Vector3f::UnitX())
+ *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
+ * This corresponds to the right-multiply conventions (with right hand side frames).
+ *
+ * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
+
+ * NOTE: ported from Eigen C++ library
+ * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/EulerAngles.h
+ * @see https://stackoverflow.com/questions/11514063/extract-yaw-pitch-and-roll-from-a-rotationmatrix
+ * @param {number[]} res
+ * @param {number[]|Float32Array|mat4} m4
+ * @param {number} a0 axis index
+ * @param {number} a1
+ * @param {number} a2
+ */
+export function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
+    const odd = ((a0 + 1) % 3 === a1) ? 0 : 1;
+
+    const i = a0;
+    const j = (a0 + 1 + odd) % 3;
+    const k = (a0 + 2 - odd) % 3;
+
+    if (a0 === a2) {
+        res[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
+        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+            if (res[0] > 0) {
+                res[0] -= EIGEN_PI;
+            } else {
+                res[0] += EIGEN_PI;
+            }
+            const s2 = v2_magnitude(coeff(m4, j, i), coeff(m4, k, i));
+            res[1] = -atan2(s2, coeff(m4, i, i));
+        } else {
+            const s2 = v2_magnitude(coeff(m4, j, i), coeff(m4, k, i));
+            res[1] = atan2(s2, coeff(m4, i, i));
+        }
+
+        // With a=(0,1,0), we have i=0; j=1; k=2, and after computing the first two angles,
+        // we can compute their respective rotation, and apply its inverse to M. Since the result must
+        // be a rotation around x, we have:
+        //
+        //  c2  s1.s2 c1.s2                   1  0   0
+        //  0   c1    -s1       *    M    =   0  c3  s3
+        //  -s2 s1.c2 c1.c2                   0 -s3  c3
+        //
+        //  Thus:  m11.c1 - m21.s1 = c3  &   m12.c1 - m22.s1 = s3
+
+        const s1 = sin(res[0]);
+        const c1 = cos(res[0]);
+        res[2] = atan2(c1 * coeff(m4, j, k) - s1 * coeff(m4, k, k), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+    } else {
+        res[0] = atan2(coeff(m4, j, k), coeff(m4, k, k));
+        const c2 = v2_magnitude(coeff(m4, i, i), coeff(m4, i, j));
+        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+            if (res[0] > 0) {
+                res[0] -= EIGEN_PI;
+            } else {
+                res[0] += EIGEN_PI;
+            }
+            res[1] = atan2(-coeff(m4, i, k), -c2);
+        } else
+            res[1] = atan2(-coeff(m4, i, k), c2);
+        const s1 = sin(res[0]);
+        const c1 = cos(res[0]);
+        res[2] = atan2(s1 * coeff(m4, k, i) - c1 * coeff(m4, j, i), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+    }
+
+    if (!odd) {
+        // invert result
+        res[0] = -res[0];
+        res[1] = -res[1];
+        res[2] = -res[2];
+    }
+
+}

package/core/geom/3d/topology/TopoMesh.js

@@ -482,7 +482,7 @@ export class TopoMesh {
         assert.equal(a.isTopoVertex, true, 'a.isTopoVertex !== true');
         assert.equal(b.isTopoVertex, true, 'b.isTopoVertex !== true');
 
-        assert.notEqual(a, b, 'a === b, attempting to create an edge from vertex to itself')
+        assert.notEqual(a, b, 'a === b, attempting to create an edge from vertex to itself');
 
         const aEdges = a.edges;
         const n = aEdges.length;

package/core/geom/Vector3.js

@@ -11,7 +11,7 @@ import { sign } from "../math/sign.js";
 import { v3_dot } from "./v3_dot.js";
 import { v3_length_sqr } from "./v3_length_sqr.js";
 import { v3_length } from "./v3_length.js";
-import { v3_angle_between } from "./v3_angle_between.js";
+import { v3_angle_between, v3_angle_between_atan2 } from "./v3_angle_between.js";
 import { v3_lerp } from "./v3_lerp.js";
 import { v3_slerp } from "./v3_slerp.js";
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
@@ -448,7 +448,7 @@ class Vector3 {
      * @returns {number}
      */
     angleTo(other) {
-        return v3_angle_between(this.x, this.y, this.z, other.x, other.y, other.z);
+        return v3_angle_between_atan2(this.x, this.y, this.z, other.x, other.y, other.z);
     }
 
     /**

package/core/geom/normalize_angle_rad.js

@@ -0,0 +1,18 @@
+import { PI2 } from "../math/MathUtils.js";
+
+/**
+ * Force angle to [-PI, +PI] range
+ * based on answer https://stackoverflow.com/a/2323034/3973586
+ * @param {number} angle in radians
+ * @return {number} in radians
+ */
+export function normalize_angle_rad(angle) {
+    let r = angle % PI2;
+    r = (r + PI2) % PI2;
+
+    if (r > Math.PI) {
+        r -= PI2;
+    }
+
+    return r;
+}

package/core/geom/normalize_angle_rad.spec.js

@@ -0,0 +1,45 @@
+import { normalize_angle_rad } from "./normalize_angle_rad.js";
+
+test('0', () => {
+    expect(normalize_angle_rad(0)).toBe(0);
+});
+
+test('PI', () => {
+    expect(normalize_angle_rad(Math.PI)).toBe(Math.PI);
+});
+
+test('-PI', () => {
+    expect(normalize_angle_rad(-Math.PI)).toBeCloseTo(Math.PI);
+});
+
+test('2*PI', () => {
+    expect(normalize_angle_rad(Math.PI * 2)).toBeCloseTo(0);
+});
+
+test('-2*PI', () => {
+    expect(normalize_angle_rad(-Math.PI * 2)).toBeCloseTo(0);
+});
+
+test('-1', () => {
+    expect(normalize_angle_rad(-1)).toBeCloseTo(-1);
+});
+
+test('-3', () => {
+    expect(normalize_angle_rad(-3)).toBeCloseTo(-3);
+});
+
+test('1', () => {
+    expect(normalize_angle_rad(1)).toBeCloseTo(1);
+});
+
+test('3', () => {
+    expect(normalize_angle_rad(3)).toBeCloseTo(3);
+});
+
+test('2*PI + 1', () => {
+    expect(normalize_angle_rad(Math.PI * 2 + 1)).toBeCloseTo(1);
+});
+
+test('- ( 2*PI + 1)', () => {
+    expect(normalize_angle_rad(-(Math.PI * 2 + 1))).toBeCloseTo(-1);
+});

package/core/geom/v3_angle_between.js

@@ -29,3 +29,25 @@ export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
 
     return Math.acos(theta);
 }
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_angle_between_atan2(x0, y0, z0, x1, y1, z1) {
+    const cx = y0 * z1 - z0 * y1;
+    const cy = z0 * x1 - x0 * z1;
+    const cz = x0 * y1 - y0 * x1;
+
+    const cross_length = v3_length(cx, cy, cz);
+
+    const d = v3_dot(x0, y0, z0, x1, y1, z1);
+
+    return Math.atan2(cross_length, d);
+}

package/engine/ecs/fow/FogOfWarRevealerSystem.js

@@ -10,6 +10,10 @@ import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 const v2 = new Vector2();
 
 export class FogOfWarRevealerSystem extends System {
+    /**
+     *
+     * @param {number} team
+     */
     constructor(team) {
         super();
 
@@ -19,6 +23,10 @@ export class FogOfWarRevealerSystem extends System {
 
         this.data = [];
 
+        /**
+         *
+         * @type {number}
+         */
         this.team = team;
     }
 

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -7,29 +7,15 @@ import Vector3 from '../../../../../core/geom/Vector3.js';
 import { assert } from "../../../../../core/assert.js";
 import { lerp } from "../../../../../core/math/lerp.js";
 import { Euler, Matrix4 } from "three";
-import { PI2 } from "../../../../../core/math/MathUtils.js";
+import { normalize_angle_rad } from "../../../../../core/geom/normalize_angle_rad.js";
+import { eulerAnglesFromMatrix } from "../../../../../core/geom/3d/eulerAnglesFromMatrix.js";
 
 const m4 = new Matrix4();
 const euler = new Euler();
+const angles = [];
 
 const panOffset = new Vector3();
 
-/**
- * Force angle to [-PI, +PI] range
- * based on answer https://stackoverflow.com/a/2323034/3973586
- * @param {number} angle in radians
- * @return {number} in radians
- */
-function normalize_angle(angle) {
-    let r = angle % PI2;
-    r = (r + PI2) % PI2;
-
-    if (r > Math.PI) {
-        r -= PI2;
-    }
-
-    return r;
-}
 
 /**
  *
@@ -40,8 +26,8 @@ function normalize_angle(angle) {
  */
 export function rotate_from_view(displacement_x, displacement_y, input, output) {
     // crop yaw and pitch to safe range of -PI to PI
-    const i_pitch = normalize_angle(input.pitch);
-    const i_yaw = normalize_angle(input.yaw);
+    const i_pitch = normalize_angle_rad(input.pitch);
+    const i_yaw = normalize_angle_rad(input.yaw);
 
     // flip rotation axis when pitch is over 90deg in either direction, that is UP vector is pointing down
     const d_yaw = ((i_pitch > Math.PI || i_pitch < -Math.PI) ? -1 : 1) * displacement_x;
@@ -138,17 +124,18 @@ class TopDownCameraController {
      * @param {Vector3} [up]
      */
     setFromEyeAndTarget(eye, target, up = Vector3.up) {
+
         /*
         NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
         See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
          */
         m4.lookAt(target, eye, up);
 
-        euler.setFromRotationMatrix(m4, 'ZYX');
+        eulerAnglesFromMatrix(angles, m4.elements, 2, 1, 0)
 
-        this.pitch = normalize_angle(euler.x);
-        this.yaw = normalize_angle(euler.y);
-        this.roll = normalize_angle(euler.z);
+        this.pitch = angles[2];
+        this.yaw = angles[1];
+        this.roll = angles[0];
 
         this.distance = eye.distanceTo(target);
 

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.spec.js

@@ -11,6 +11,15 @@ test('setFromEyeAndTarget does not introduce roll when UP is aligned with +Y', (
     expect(ut.roll).toBe(0);
 });
 
+test('setFromEyeAndTarget, with different directional axial combinations', () => {
+    const ut = new TopDownCameraController();
+
+    ut.setFromEyeAndTarget(new Vector3(0, 1, -1), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
+    ut.setFromEyeAndTarget(new Vector3(0, 1, -1), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
+
+    expect(ut.roll).toBe(0);
+});
+
 test('setFromEyeAndTarget results in roll respecting UP vector', () => {
     const eye = new Vector3();
     const target = new Vector3();

package/engine/graphics/geometry/buffered/deinterleaveBufferAttribute.js

@@ -28,9 +28,10 @@ export function deinterleaveBufferAttribute(source_attribute) {
     attribute.normalized = source_attribute.normalized;
     attribute.name = source_attribute.name;
 
+    let i = 0, j = 0;
     // copy data
-    for (let i = 0; i < item_count; i++) {
-        for (let j = 0; j < itemSize; j++) {
+    for (; i < item_count; i++) {
+        for (j = 0; j < itemSize; j++) {
             destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
         }
     }

package/generation/example/SampleGenerator0.js

@@ -21,7 +21,6 @@ import { matcher_tag_traversable } from "./rules/matcher_tag_traversable.js";
 import { GridTaskGenerateRoads } from "../grid/generation/road/GridTaskGenerateRoads.js";
 import { mir_generator_place_road_decorators } from "./generators/mir_generator_place_road_decorators.js";
 import { MarkerNodeMatcherByType } from "../markers/matcher/MarkerNodeMatcherByType.js";
-import { mir_generator_place_buff_objects } from "./generators/interactive/mir_generator_place_buff_objects.js";
 import { GridTaskDensityMarkerDistribution } from "../grid/generation/GridTaskDensityMarkerDistribution.js";
 import { CellFilterSimplexNoise } from "../filtering/numeric/complex/CellFilterSimplexNoise.js";
 import { NumericInterval } from "../../core/math/interval/NumericInterval.js";
@@ -211,12 +210,11 @@ const prEnemyCorridorGuard = GridCellPlacementRule.from(
         ), actions: [
             ACTION_PLACE_ENEMY_MARKER,
             ACTION_PLACE_ENEMY_TAG
-        ]
+        ],
+        probability: CellFilterLiteralFloat.from(0.5)
     }
 );
 
-prEnemyCorridorGuard.probability = 0.5;
-
 const gRuleSet2 = GridTaskActionRuleSet.from({ rules: GridActionRuleSet.from({ rules: [prEnemyTreasureGuard, prEnemyCorridorGuard] }) });
 
 gRuleSet2.addDependency(gRuleSetTreasureGuards);
@@ -226,7 +224,11 @@ const gPlaceStartingPoint = mir_generator_place_starting_point();
 
 gPlaceStartingPoint.addDependency(gConnectRooms);
 
-const gBuildDistanceMap = GridTaskBuildSourceDistanceMap.from({ source: MATCH_STARTING_POINT, pass: MATCH_EMPTY });
+const gBuildDistanceMap = GridTaskBuildSourceDistanceMap.from({
+    source: MATCH_STARTING_POINT,
+    pass: MATCH_EMPTY,
+    layer: MirGridLayers.DistanceFromStart
+});
 
 gBuildDistanceMap.addDependency(gPlaceStartingPoint);
 
@@ -235,11 +237,8 @@ gRuleSet1.addDependency(gBuildDistanceMap);
 const gBases = mir_generator_place_bases();
 gBases.addDependency(gMakeEmpty);
 
-const gBuffObjects = mir_generator_place_buff_objects();
-gBuffObjects.addDependency(gBases);
 
 gConnectRooms.addDependency(gBases);
-gConnectRooms.addDependency(gBuffObjects);
 
 gPlaceStartingPoint.addDependency(gBases);
 
@@ -250,7 +249,6 @@ const gRoads = new GridTaskGenerateRoads();
 
 gRoads.addDependency(gConnectRooms);
 gRoads.addDependency(gBases);
-gRoads.addDependency(gBuffObjects);
 
 const gRoadDecorators = mir_generator_place_road_decorators();
 
@@ -540,7 +538,6 @@ gFoliageLarge.addDependencies([
     gRuleSet1,
     gRuleSet2,
     gRuleSetTreasureGuards,
-    gBuffObjects,
     gBases
 ]);
 
@@ -555,7 +552,6 @@ SampleGenerator0.addGenerator(gConnectRooms);
 SampleGenerator0.addGenerator(gRoads);
 SampleGenerator0.addGenerator(gRoadDecorators);
 SampleGenerator0.addGenerator(gBases);
-SampleGenerator0.addGenerator(gBuffObjects);
 SampleGenerator0.addGenerator(gPlaceStartingPoint);
 SampleGenerator0.addGenerator(gBuildDistanceMap);
 SampleGenerator0.addGenerator(gRuleSet1);

package/generation/example/main.js

@@ -0,0 +1,215 @@
+import { EngineHarness } from "../../engine/EngineHarness.js";
+import RenderSystem from "../../engine/ecs/systems/RenderSystem.js";
+import { Camera } from "../../engine/graphics/ecs/camera/Camera.js";
+import TopDownCameraController from "../../engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
+import Vector3 from "../../core/geom/Vector3.js";
+import { TopDownCameraLander } from "../../engine/graphics/ecs/camera/topdown/TopDownCameraLander.js";
+import Terrain from "../../engine/ecs/terrain/ecs/Terrain.js";
+import { TerrainFlags } from "../../engine/ecs/terrain/ecs/TerrainFlags.js";
+import Water from "../../engine/graphics/ecs/water/Water.js";
+import GridObstacle from "../../engine/grid/components/GridObstacle.js";
+import EntityBuilder from "../../engine/ecs/EntityBuilder.js";
+import GridPosition from "../../engine/grid/components/GridPosition.js";
+import { Transform } from "../../engine/ecs/transform/Transform.js";
+import { GridData } from "../grid/GridData.js";
+import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
+import { ThemeEngine } from "../theme/ThemeEngine.js";
+import { AreaTheme } from "../theme/AreaTheme.js";
+import TaskGroup from "../../core/process/task/TaskGroup.js";
+import { actionTask } from "../../core/process/task/TaskUtils.js";
+import { generateTerrainPreview } from "../../../../generator/generator/generateTerrainPreview.js";
+import { SampleTheme0 } from "./themes/SampleTheme0.js";
+import { SampleGenerator0 } from "./SampleGenerator0.js";
+import { configureMirGrid } from "./grid/configureMirGrid.js";
+import { EngineConfiguration } from "../../engine/EngineConfiguration.js";
+import TerrainSystem from "../../engine/ecs/terrain/ecs/TerrainSystem.js";
+import WaterSystem from "../../engine/graphics/ecs/water/WaterSystem.js";
+import { MeshSystem } from "../../engine/graphics/ecs/mesh/MeshSystem.js";
+import TopDownCameraControllerSystem from "../../engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { TopDownCameraLanderSystem } from "../../engine/graphics/ecs/camera/topdown/TopDownCameraLanderSystem.js";
+import LightSystem from "../../engine/graphics/ecs/light/LightSystem.js";
+
+function makeEngineConfig(engine) {
+    const config = new EngineConfiguration();
+
+    const graphics = engine.graphics;
+
+    config.addSystem(new RenderSystem(graphics));
+    config.addSystem(new TerrainSystem(graphics, engine.assetManager));
+    config.addSystem(new WaterSystem(graphics));
+    config.addSystem(new MeshSystem(engine));
+    config.addSystem(new TopDownCameraControllerSystem());
+    config.addSystem(new TopDownCameraLanderSystem());
+    config.addSystem(new LightSystem(engine))
+
+    return config;
+}
+
+
+/**
+ *
+ * @param {EngineHarness} harness
+ * @return {Promise<void>}
+ */
+async function init(harness) {
+    const engine = harness.engine;
+
+    await makeEngineConfig(engine).apply(engine);
+
+    await harness.initialize();
+
+    main(engine);
+}
+
+function prepare_gen_task({
+                              SIZE_X = 64,
+                              SIZE_Y = 64,
+                              ecd
+                          }) {
+
+    const camera = EngineHarness.buildCamera({
+        engine,
+        target: new Vector3(15, 0, 16),
+        // pitch: -PI_HALF,
+        pitch: 1.1,
+        yaw: 3.14,
+        distance: 13,
+        ecd,
+        distanceMin: 5,
+        distanceMax: 30
+    });
+
+    camera.add(new TopDownCameraLander());
+
+    // build lights
+    EngineHarness.buildLights({ engine })
+
+
+    // build terrain
+    const terrain = new Terrain();
+
+    terrain.resolution = 4;
+
+    terrain.size.set(SIZE_X, SIZE_Y);
+    terrain.samplerHeight.resize(SIZE_X, SIZE_Y);
+    terrain.splat.resize(SIZE_X * 4, SIZE_Y * 4, 0);
+
+    terrain.layers.resolution.set(512, 512);
+
+    terrain.clearFlag(TerrainFlags.Built);
+    terrain.build(engine.assetManager);
+
+    const water = new Water();
+
+    water.color.setRGB(0.2, 0.0, 0.5);
+    water.shoreColor.setRGB(0.3, 0.3, 1);
+    water.shoreDepthTransition.set(0.16, 0.5);
+    water.waveFrequency.set(1.3);
+    water.waveAmplitude.set(0.15);
+    water.waveSpeed.set(1.2);
+    water.scattering.set(1.2);
+    water.level.set(-0.3);
+
+    const obstacle = new GridObstacle();
+    obstacle.resize(terrain.size.x, terrain.size.y);
+
+    const terrainBuilder = new EntityBuilder();
+
+    terrainBuilder
+        .add(terrain)
+        .add(water)
+        .add(obstacle)
+        .add(new GridPosition())
+        .add(new Transform())
+        .build(ecd);
+
+
+    const gridData = new GridData();
+
+    configureMirGrid(gridData);
+
+    gridData.resize(terrain.size.x, terrain.size.y);
+    gridData.computeScale(1);
+
+    const generator = SampleGenerator0;
+
+    const tGenerationTask = generator.generate(ecd, gridData, computeStringHash('alexx855'));
+
+
+    const themeEngine = new ThemeEngine();
+    themeEngine.assetManager = engine.assetManager;
+
+    const theme0 = new AreaTheme();
+
+    const width = gridData.width;
+    const height = gridData.height;
+
+    theme0.mask.resize(width, height);
+    theme0.mask.mask.fill(0, 0, width, height, [1]);
+    theme0.theme = SampleTheme0;
+
+    themeEngine.add(theme0);
+
+
+    themeEngine.random.setCurrentSeed(1);
+    const tTheme = themeEngine.apply(gridData, ecd);
+
+    tTheme.addDependency(tGenerationTask);
+
+
+    const tBuildLevel = new TaskGroup([tGenerationTask, tTheme]);
+
+
+    const tAddGameplayElements = actionTask(() => {
+        // prepare gameplay-specific things on top of the generated level
+
+        //build minimap
+        const terrainPreview = generateTerrainPreview(terrainBuilder.entity, ecd);
+        terrain.preview.copy(terrainPreview);
+    });
+
+    tAddGameplayElements.addDependency(tBuildLevel);
+
+    return new TaskGroup([tBuildLevel, tAddGameplayElements]);
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function main(engine) {
+    const ecd = engine.entityManager.dataset;
+
+    const tBuildLevel = prepare_gen_task({ ecd });
+
+    engine.loadSlowTask(tBuildLevel);
+
+    engine.executor.runGroup(tBuildLevel);
+
+    tBuildLevel.promise().then(() => {
+        console.log('Generation took ', tBuildLevel.getExecutedCpuTime(), 'ms');
+
+        const camera = ecd.getAnyComponent(Camera);
+
+        EngineHarness.buildOrbitalCameraController({
+            cameraEntity: camera.entity,
+            engine
+        });
+
+        // tweak camera for prototyping
+        const ctrl = ecd.getComponent(camera.entity, TopDownCameraController);
+        if (ctrl !== undefined) {
+            ctrl.distanceMax = 200;
+        }
+
+    });
+
+    // Resume audio context
+    engine.devices.pointer.on.down.addOne(engine.sound.resumeContext, engine.sound);
+    engine.devices.pointer.on.wheel.addOne(engine.sound.resumeContext, engine.sound);
+
+}
+
+const engineHarness = new EngineHarness();
+
+init(engineHarness);

package/generation/example/themes/SampleTheme0.js

@@ -46,6 +46,8 @@ import { SoundEmitter } from "../../../engine/sound/ecs/emitter/SoundEmitter.js"
 import { SampleGroundMoistureFilter } from "../filters/SampleGroundMoistureFilter.js";
 import GeneratedArmy from "../../../../model/game/ecs/component/generator/army/GeneratedArmy.js";
 import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
+import { TerrainLayerDescription } from "../../theme/TerrainLayerDescription.js";
+import Vector2 from "../../../core/geom/Vector2.js";
 
 export const SampleTheme0 = new Theme();
 
@@ -123,10 +125,6 @@ const filterSand = CellFilterMultiply.from(
     filterNotRockAndNotRoad
 );
 
-const TERRAIN_LAYER_GRASS = 0;
-const TERRAIN_LAYER_ROCK = 1;
-const TERRAIN_LAYER_SAND = 3;
-
 terrainTheme.rules.push(TerrainLayerRule.from(
     CellFilterMultiply.from(
         CellFilterMultiply.from(
@@ -135,22 +133,34 @@ terrainTheme.rules.push(TerrainLayerRule.from(
         ),
         filterNotRockAndNotRoad
     ),
-    TERRAIN_LAYER_GRASS
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/materials/Sci-Fi Planet/Grass_02.png',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
     filterRock,
-    TERRAIN_LAYER_ROCK
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/Materials_Stylized/4k JPEG/Stylized_04_Rocks/Stylized_04_Rocks_basecolor.jpg',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
     filterSand,
-    TERRAIN_LAYER_SAND
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/Materials_Stylized/4k JPEG/Stylized_06_Sand/Stylized_06_Sand_basecolor.jpg',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
     filterRoad,
-    2,
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/Materials_Stylized/4k JPEG/Stylized_02_Stone_Ground/Stylized_02_Stone_Ground_basecolor.jpg',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
@@ -158,7 +168,10 @@ terrainTheme.rules.push(TerrainLayerRule.from(
         ROAD_FILTER,
         CellFilterLerp.from(CellFilterLiteralFloat.from(1), CellFilterLiteralFloat.from(0.3), NOISE_10_a)
     ),
-    TERRAIN_LAYER_GRASS,
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/materials/Sci-Fi Planet/Grass_02.png',
+        size:new Vector2(7,7)
+    }),
 ));
 
 SampleTheme0.terrain = terrainTheme;

package/generation/placement/GridCellPlacementRule.js

@@ -44,7 +44,7 @@ export class GridCellPlacementRule {
      * @param {Vector2} [offset]
      * @returns {GridCellPlacementRule}
      */
-    static from({ matcher, actions, probability, offset = Vector2.zero }) {
+    static from({ matcher, actions, probability = CellFilterLiteralFloat.from(1), offset = Vector2.zero }) {
 
         assert.defined(matcher);
         assert.defined(actions);
@@ -56,10 +56,8 @@ export class GridCellPlacementRule {
         r.pattern = matcher;
         r.actions = actions;
 
-        if (probability !== undefined) {
-            assert.equal(probability.isCellFilter, true, 'probability.isCellFilter !== true');
-            r.probability = probability;
-        }
+        assert.equal(probability.isCellFilter, true, 'probability.isCellFilter !== true');
+        r.probability = probability;
 
         r.positionOffset.copy(offset);
 

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