@woosh/meep-engine 2.33.67 → 2.33.71

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/3d/triangle/computeTriangleRayIntersection.js

@@ -25,15 +25,9 @@ export function computeTriangleRayIntersection(
     result,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z,
-    ax,
-    ay,
-    az,
-    bx,
-    by,
-    bz,
-    cx,
-    cy,
-    cz
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
 ) {
 
     // edge1 = a - b

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/engine/asset/loaders/GLTFAssetLoader.js

@@ -26,7 +26,6 @@ import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/trave
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";
 import { async_traverse_three_object } from "./async_traverse_three_object.js";
-import { deinterleaveBufferGeometry } from "../../graphics/geometry/buffered/deinterleaveBufferGeometry.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
@@ -294,9 +293,6 @@ export class GLTFAssetLoader extends AssetLoader {
                 mesh.geometry = geometry;
             }
 
-            mesh.geometry = deinterleaveBufferGeometry(geometry);
-
-
             if (this.__enable_texture_cache) {
                 // replace textures from cache
                 replace_material_textures_from_cache(mesh.material, texture_cache);

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,30 +7,14 @@ 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 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;
-}
-
 /**
  *
  * @param {number} displacement_x
@@ -40,8 +24,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;
@@ -146,9 +130,29 @@ class TopDownCameraController {
 
         euler.setFromRotationMatrix(m4, 'ZYX');
 
-        this.pitch = normalize_angle(euler.x);
-        this.yaw = normalize_angle(euler.y);
-        this.roll = normalize_angle(euler.z);
+        const angles = [];
+        eulerAnglesFromMatrix(angles, m4.elements, 2, 1, 0);
+
+        const _p0 = normalize_angle_rad(euler.x);
+        const _y0 = normalize_angle_rad(euler.y);
+        const _r0 = normalize_angle_rad(euler.z);
+
+        this.pitch = _p0;
+        this.yaw = _y0;
+        this.roll = _r0;
+
+
+        const _p1 = angles[2];
+        const _y1 = angles[1];
+        const _r1 = angles[0];
+
+        if (_p0 !== _p0 || _y0 !== _y1 || _r0 !== _r1) {
+            console.warn('Angular discrepancy');
+        }
+
+        this.pitch = _p1;
+        this.yaw = _y1;
+        this.roll = _r1;
 
         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/engine/graphics/geometry/buffered/query/ClippingPlaneContainmentComputingVisitor.js

@@ -79,21 +79,32 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             for (let i = 0; i < plane_count; i++) {
                 const plane = planes[i];
@@ -108,15 +119,9 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_y,
                     plane_normal_z,
                     plane_constant,
-                    ax,
-                    ay,
-                    az,
-                    bx,
-                    by,
-                    bz,
-                    cx,
-                    cy,
-                    cz
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
                 );
 
                 if (side === -3) {
@@ -163,12 +168,8 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_z,
                     plane_constant,
 
-                    x0,
-                    y0,
-                    z0,
-                    x1,
-                    y1,
-                    z1
+                    x0, y0, z0,
+                    x1, y1, z1
                 );
 
                 if (side === -2) {

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

@@ -1,6 +1,6 @@
 import { IndexedBinaryBVHVisitor } from "../../../../../core/bvh2/binary/IndexedBinaryBVHVisitor.js";
 
-export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
+export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor {
     constructor() {
         super();
 
@@ -25,6 +25,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
          */
         this.__buffer_vertices = null;
 
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_vertex_stride = 3;
+
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_position_offset = 0;
+
         /**
          * @protected
          * @type {IndexedBinaryBVH}
@@ -47,7 +61,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
         this.geometry = geometry;
 
         this.__buffer_indices = geometry.getIndex().array;
-        this.__buffer_vertices = geometry.getAttribute('position').array;
+
+        const position_attribute = geometry.getAttribute('position');
+
+        if (position_attribute.isInterleavedBufferAttribute) {
+            const data = position_attribute.data;
+
+            this.__buffer_vertices = data.array;
+            this.__buffer_vertex_stride = data.stride;
+            this.__buffer_position_offset = position_attribute.offset;
+        } else {
+            this.__buffer_vertices = position_attribute.array;
+            this.__buffer_vertex_stride = 3;
+            this.__buffer_position_offset = 0;
+        }
     }
 
 }

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

@@ -96,21 +96,32 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             if (computeTriangleRayIntersection(
                 this.__temp_hit,
@@ -120,15 +131,9 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
                 rayDirection.x,
                 rayDirection.y,
                 rayDirection.z,
-                ax,
-                ay,
-                az,
-                bx,
-                by,
-                bz,
-                cx,
-                cy,
-                cz
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
             )) {
                 const d = this.__temp_hit.position.distanceSqrTo(rayOrigin);
 
@@ -154,12 +159,8 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const z1 = data[address + 5];
 
             return intersectRay(
-                x0,
-                y0,
-                z0,
-                x1,
-                y1,
-                z1,
+                x0, y0, z0,
+                x1, y1, z1,
 
                 rayOrigin.x,
                 rayOrigin.y,

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